The walrus operator did not exist before 3.8, there was no real alternative before. The backlash was from people who dislike the idea and would prefer Python didn't add it.

The operator didn’t exist but the functionality did. It was just a side effect of python’s wonky variable scoping which they gave an operator.

I’m not familiar with how it works now but the example I remember was the variables escaping from list comprehension statements, like:

  x = [y for y in z]
  if y != z[-1]:
    bad_stuff_happened()

Or something like that, maybe I’m wrong, honestly never had a use for the walrus.

Python’s scoping rules are wonky, but the walrus is generally useful in two cases. The first one is to define a variable in an `if` and only run the contents of the `if` if the variable is truey — for example, re.search returns a Match object or None:

    if (m := re.search("regex is(n't)? fun")):
        print("there was a match")
        # do something with m

The other would be defining a variable in the `if` clause of a list comprehension and using it in the output (which is not necessary in languages where map/filter is a first-class citizen, because you could just map before you filter):

    [y for x in xs if (y := f(x)) == 5]

I can’t think of a way to define a variable in either of those cases without using the walrus and without significantly extending the code (you can define the `m` object and then do `if m:` on two lines, or you can nest two list comprehensions).

There's also:

  while data := fh.read(131072):
    # do stuff

which is a lot nicer than:

  while True:
    data = fh.read()
    if not data: break
    # do stuff