> Is Python the language that comes closest to this goal? And if not, which is?

In the end, it's subjective. And "understandable" and "plain English" may not sit together well, as it can lead to overly verbose code.

But, here's a few examples for you to judge between. (Examples lifted from RosettaCode, which is well worth the look.)

All these languages have claimed, at some time or another, to be easy to read, and close to "plain English". Obviously, this is just a taste.

Python

    def fib(n,x=[0,1]):
       for i in range(abs(n)-1): x=[x[1],sum(x)]
       return x[1]*pow(-1,abs(n)-1) if n<0 else x[1] if n else 0

    for i in range(-30,31): print fib(i),

Ada (A safety-oriented language)

    with Ada.Text_IO, Ada.Command_Line;
    procedure Fib is
        X: Positive := Positive'Value(Ada.Command_Line.Argument(1));

       function Fib(P: Positive) return Positive is
       begin
          if P <= 2 then
             return 1;
          else
             return Fib(P-1) + Fib(P-2);
          end if;
       end Fib;
 
    begin
       Ada.Text_IO.Put("Fibonacci(" & Integer'Image(X) & " ) = ");
       Ada.Text_IO.Put_Line(Integer'Image(Fib(X)));
    end Fib;

AppleScript (Seeing less support from Apple these days, but part of macOS)

    on fib(n)
        if n < 1 then
            0
        else if n < 3 then
            1
        else
            fib(n - 2) + fib(n - 1)
        end if
    end fib

BASIC (Easy to read, easy to use, easy to get lost.)

    FUNCTION itFib (n)
        n1 = 0
        n2 = 1
        FOR k = 1 TO ABS(n)
            sum = n1 + n2
            n1 = n2
            n2 = sum
        NEXT k
        IF n < 0 THEN
            itFib = n1 * ((-1) ^ ((-n) + 1))
        ELSE
            itFib = n1
        END IF
    END FUNCTION

Clojure (A modern Lisp, bits of Scheme, Common Lisp and Java)

    (defn fibs []
      (map first (iterate (fn [[a b]] [b (+ a b)]) [0 1])))

COBOL, it's so ridiculously verbose, I'm not adding it here. See https://www.rosettacode.org/wiki/Fibonacci_sequence#COBOL

CoffeeScript (Billed as a better JavaScript, it was popular until ES2016)

    fib_rec = (n) ->
      if n < 2 then n else fib_rec(n-1) + fib_rec(n-2)

Delphi (One of my first programming languages. Probably the least verbose staticly typed language without inference I've seen.)

    function FibonacciI(N: Word): UInt64;
    var
      Last, New: UInt64;
      I: Word;
    begin
      if N < 2 then
        Result := N
      else begin
        Last := 0;
        Result := 1;
        for I := 2 to N do
        begin
          New := Last + Result;
          Last := Result;
          Result := New;
        end;
      end;
    end;
 

Elixir (Kinda like Ruby, but running atop Erlang's massively-concurrent VM.)

    defmodule Fibonacci do
        def fib(0), do: 0
        def fib(1), do: 1
        def fib(n), do: fib(0, 1, n-2)
 
        def fib(_, prv, -1), do: prv
        def fib(prvprv, prv, n) do
            next = prv + prvprv
            fib(prv, next, n-1)
        end
    end
 
    IO.inspect Enum.map(0..10, fn i-> Fibonacci.fib(i) end)

Elm (A new language for the web. More a framework that replaces HTML, CSS and JS than just JS.)

    fibonacci : Int -> Int
    fibonacci n = if n < 2 then
            n
        else
            fibonacci(n - 2) + fibonacci(n - 1)

FORTRAN (I've done too much professional work with FORTRAN to like it. It looks straight-forward, but you can do pretty much whatever you feel like with memory, and it'll let you.)

      FUNCTION IFIB(N)
      IF (N.EQ.0) THEN
        ITEMP0=0
      ELSE IF (N.EQ.1) THEN
        ITEMP0=1
      ELSE IF (N.GT.1) THEN
        ITEMP1=0
        ITEMP0=1
        DO 1 I=2,N
          ITEMP2=ITEMP1
          ITEMP1=ITEMP0
          ITEMP0=ITEMP1+ITEMP2
    1   CONTINUE
      ELSE
        ITEMP1=1
        ITEMP0=0
        DO 2 I=-1,N,-1
          ITEMP2=ITEMP1
          ITEMP1=ITEMP0
          ITEMP0=ITEMP2-ITEMP1
    2   CONTINUE
      END IF
      IFIB=ITEMP0
      END

Go (Google's somewhat naive language, can be odd to set up, but is fast, static and fairly readable. Lots of people switch from Python to Go.)

    func fib(a int) int {
      if a < 2 {
        return a
      }
      return fib(a - 1) + fib(a - 2)
    }

Julia (It's a language aimed at scientific application. That means a great number system, a really good compiler, and access to things you usually need FORTRAN for.)

    fib(n) = n < 2 ? n : fib(n-1) + fib(n-2)

Lua (Fast but small. Standard library isn't much bigger than C, but has LuaRocks, a decent package manager, with an active community. Some think of it as a better JavaScript, though it was designed for embedding and has a fantastic C-interop story.)

    function fibs(n) 
      return n < 2 and n or fibs(n - 1) + fibs(n - 2) 
    end

Nim (Think Python, but staticly typed, and much faster.)

    proc Fibonacci(n: int): auto =
      var fn = float64(n)
      var p: float64 = (1.0 + sqrt(5.0)) / 2.0
      var q: float64 = 1.0 / p
          return int64((pow(p, fn) + pow(q, fn)) / sqrt(5.0))