Feature power_list to return all powers of a variable present in f

sympy/polys/polytools.py

@@ -1818,6 +1818,32 @@ def total_degree(f):
         else:  # pragma: no cover
             raise OperationNotSupported(f, 'total_degree')
 
+    def power_list(f):
+        """
+        Returns a list of powers of variables in ``f``.
+
+        Examples
+        ========
+
+        >>> from sympy import Poly
+        >>> from sympy.abc import x, y
+
+        >>> Poly(x**2 + y*x + 1, x, y).power_list()
+        [(2, 1, 0), (1, 0)]
+        >>> Poly(0, x).power_list()
+        [(0,)]
+        >>> Poly(x, x).power_list()
+        [(1,)]
+        """
+        power = []
+        for i in range(len(f.gens)):
+            tmp = []
+            for j in f.monoms():
+                tmp.append(j[i])
+            tmp = reversed(list(set(tmp)))
+            power.append(tuple(tmp))
+        return power
+
     def homogenize(f, s):
         """
         Returns the homogeneous polynomial of ``f``.
@@ -4551,6 +4577,36 @@ def degree_list(f, *gens, **args):
 
     return tuple(map(Integer, degrees))
 
+@public
+def power_list(f, *gens, **args):
+    """
+    Return a list of powers of ``f`` in all variables.
+
+    Examples
+    ========
+
+    >>> from sympy import power_list
+    >>> from sympy.abc import x, y
+
+    >>> power_list(x**2 + y*x + 1)
+    [(2, 1, 0), (1, 0)]
+    >>> power_list(0, x)
+    [(0,)]
+    >>> power_list(x, x)
+    [(1,)]
+
+    """
+    options.allowed_flags(args, ['polys'])
+
+    try:
+        F, opt = poly_from_expr(f, *gens, **args)
+    except PolificationFailed as exc:
+        raise ComputationFailed('power_list', 1, exc)
+
+    powers = F.power_list()
+
+    return list(powers)
+
 
 @public
 def LC(f, *gens, **args):

sympy/polys/tests/test_polytools.py

@@ -5,6 +5,7 @@
     parallel_poly_from_expr,
     degree, degree_list,
     total_degree,
+    power_list,
     LC, LM, LT,
     pdiv, prem, pquo, pexquo,
     div, rem, quo, exquo,
@@ -1220,6 +1221,30 @@ def test_Poly_total_degree():
     assert total_degree(Poly(y**2 + x**3 + z**4, x), z) == 4
     assert total_degree(Poly(x**9 + x*z*y + x**3*z**2 + z**7,x), z) == 7
 
+def test_Poly_power_list():
+    assert Poly(0, x).power_list() == [(0,)]
+    assert Poly(0, x, y).power_list() == [(0,), (0,)]
+    assert Poly(0, x, y, z).power_list() == [(0,), (0,), (0,)]
+
+    assert Poly(1, x).power_list() == [(0,)]
+    assert Poly(1, x, y).power_list() == [(0,), (0,)]
+    assert Poly(1, x, y, z).power_list() == [(0,), (0,), (0,)]
+
+    assert Poly(x**2*y + x**3*z**2 + 1).power_list() == [(3, 2, 0), (1, 0), (2, 0)]
+
+    assert power_list(x, x) == [(1,)]
+
+    assert power_list(x*y**2 + x + 1) == [(1, 0), (2, 0)]
+    assert power_list(x*y**2 + x) == [(1,), (2, 0)] # power of y is zero with x
+    assert power_list(x*y**2) == [(1,), (2,)]
+
+    assert power_list(x**8*(1 - x)**9) == [(17, 16, 15, 14, 13, 12, 11, 10, 9, 8)]
+    # >>>expand(x**8*(1 - x)**9)
+    # -x**17 + 9*x**16 - 36*x**15 + 84*x**14 - 126*x**13 + 126*x**12 - 84*x**11
+    # + 36*x**10 - 9*x**9 + x**8
+
+    raises(ComputationFailed, lambda: power_list(1))
+
 def test_Poly_homogenize():
     assert Poly(x**2+y).homogenize(z) == Poly(x**2+y*z)
     assert Poly(x+y).homogenize(z) == Poly(x+y, x, y, z)