Let's suppose that the input of the problem is a character string that represents a polynomial of arbitrary degree (maximum 9), like the following:

entrada = "23x³+5x²+10x+5"

The problem of detecting the coefficients can be attacked by using a regular expression that looks for digits optionally followed by one xthat is optionally followed by a unicode "exponent" character. The following regular expression does this, although it becomes more complicated than necessary for wanting to also deal with the cases in which the coefficient or the exponent is not written, because it is 1:

regexp = r"(-?\d*)(x?)([¹²³⁴⁵⁶⁷⁸⁹]*)"

and incidentally it captures in different capture groups the digits that appear before the x(and an optional one -in case the coefficient is negative), its own x(which is actually optional so that it also works with the independent term) and the Unicode digits of the exponent. The digits in front of the x are optional as well as the digits of the exponent, as they may not appear as in "x+1".

After applying that regular expression, we iterate through the resulting groups to save what we find in a dictionary. The key of the dictionary will be the exponent and the value will be the corresponding coefficient. Some cases must be detected and treated in a special way:

• If neither the x nor the coefficient appears, we skip that case
• If the coefficient does not appear but the x does, the coefficient is "1"
• If the x appears and the "coefficient" is simply a "-", the coefficient is "-1".
• If the x appears but not the exponent, the exponent is "1"
• If the coefficient appears but not the x, it is the independent term

These special cases mess up the code a bit, which would look like this:

c = {}
for coef, x, exp in re.findall(regexp, entrada):
  if not coef and not x:
    continue
  if x and not coef:
    coef = '1'
  if x and coef == "-":
    coef = '-1'
  if x and not exp:
    exp = '1'
  if coef and not x:
    exp = '0'
  exp = ord(exp) & 0x000F
  c[exp] = float(coef)

The line exp = ord(exp) & 0x000Fis a "dirty trick". It happens that the Unicode characters of the exponents, like the ASCII codes of the digits, are ordered in such a way that their last hexadecimal figure coincides with the number they represent. For example, the Unicode for ² is 0x00B2, for ³ is 0x00B3, for ⁴ is 0x2074, etc, as you can see here

Taking advantage of this fact, through &logic I set all the bits of the code to 0 except the last 4, and that therefore gives me the figure they represent.

The result is this dictionary:

{0: 5.0, 1: 10.0, 2: 5.0, 3: 23.0}

All that remains is to convert that dictionary into a list so that the index is the exponent and the value is the coefficient. For the thing to be general enough, we first look at what is the largest of the keys (in this case 3), since that gives us the degree of the polynomial and therefore the necessary size of the resulting list. The rest is just filling in:

grado = max(c)
coeficientes = [0.0] * (grado+1)
for g, v in c.items():
  coeficientes[g] = v

The result in this case is:

[5.0, 10.0, 5.0, 23.0]

In the question the user asks for the opposite order, I suppose by mistake, since the logical thing is that the index [i]of this list gives us the coefficient of the i-th power of x. In any case, if you really need it the other way around, just do a finalcoeficientes.reverse()

Let's put all of the above into one function:

import re

def coefs(entrada):
  regexp = r"(-?\d*)(x?)([¹²³⁴⁵⁶⁷⁸⁹]*)"
  c = {}
  for coef, x, exp in re.findall(regexp, entrada):
    if not coef and not x:
      continue
    if x and not coef:
      coef = '1'
    if x and coef == "-":
      coef = "-1"
    if x and not exp:
      exp = '1'
    if coef and not x:
      exp = '0'
    exp = ord(exp) & 0x000F
    c[exp] = float(coef)
  grado = max(c)
  coeficientes = [0.0] * (grado+1)
  for g, v in c.items():
    coeficientes[g] = v
  return coeficientes

Note The algorithm works also if the terms are out of order, if some are missing (the corresponding coefficient will be zero) or if there are gaps between coefficients. It doesn't work instead if there is a negative coefficient with a space between the minus sign and the number.

Examples of inputs and their corresponding outputs:

>>> coefs("25x²")
[0.0, 0.0, 25.0]

>>> coefs("25x⁵-x+3")
[3.0, -1.0, 0.0, 0.0, 0.0, 25.0]

>>> coefs("x-23")
[-23.0, 1.0]

>>> coefs("x²-x+1")
[1.0, -1.0, 1.0]

I've tried more, and it's worked, but I may have missed some other "special case". Of course it doesn't do symbolic operations, so it won't work with a polynomial like "x+x"(doesn't add the x's) either.

Update

If instead of unicode exponents the exponents come in the form x**Nor x^N, the regular expression gets a bit more complicated (to admit both variants) and would be:

regexp = r"(-?\d*)(x?)(?:(?:\^|\*\*)(\d))?"

That is, the function would be the following:

import re

def coefs(entrada):
  regexp = r"(-?\d*)(x?)(?:(?:\^|\*\*)(\d))?"
  c = {}
  for coef, x, exp in re.findall(regexp, entrada):
    # print(coef, x, exp)
    if not coef and not x:
      continue
    if x and not coef:
      coef = '1'
    if x and coef == "-":
      coef = "-1"
    if x and not exp:
      exp = '1'
    if coef and not x:
      exp = '0'
    exp = ord(exp) & 0x000F
    c[exp] = float(coef)
  grado = max(c)
  coeficientes = [0.0] * (grado+1)
  for g, v in c.items():
    coeficientes[g] = v
  return coeficientes

Trying some examples seems to work fine:

ejemplos = ["x**2-x+1", "x^2-x+1", "25x^2", "25x**2", "5x^5-x**2+3"]
for e in ejemplos:
  print(e, "\n ", coefs(e))

x**2-x+1 
  [1.0, -1.0, 1.0]
x^2-x+1 
  [1.0, -1.0, 1.0]
25x^2 
  [0.0, 0.0, 25.0]
25x**2 
  [0.0, 0.0, 25.0]
5x^5-x**2+3 
  [3.0, 0.0, -1.0, 0.0, 0.0, 5.0]