在Python中根据个位，十位，百位数字对列表进行排序

Question

假设我有一个列表，我想按以下模式对数字进行排序：

A = [3, 30, 34, 256, 5, 9]

先按个位数字排序，如果个位数字相同，我们将比较tens place，然后比较hundred place。如果您按此规则对 A 进行排序，则：

A = [9, 5, 34, 3, 30, 256]

9 is the highest digit at Unit place 
5 is second highest
3, 34, 30 since unit digit is same here, we will compare tens place so 34 will come first here, then 3 and 30.
256 will come last since its unit place digit is 2 which is the lowest.

Suppose B = [100, 10, 1]
then after sorting B = [1, 10, 100]

谁能分享一些 Pythonic 的方法来解决这个问题？

我已经尝试过sorted(nums, key=lambda x: int(x[0]), reverse=True)，但在这里我将如何考虑tenth place digit？

更新：假设A = [1, 100, 10] 那么在对A = [1, 10, 100] 进行排序之后的这种情况下，缺少一点。在示例中，我在对A = [9, 5, 34, 3, 30, 256] 进行排序后在这里给出了A = [3, 30, 34, 256, 5, 9]。

总体逻辑是我想加入所有数字并创建一个最大的 号码。

Answer 1

我认为你只需要 str 作为键：

In [11]: sorted(A, key=str, reverse=True)
Out[11]: [9, 5, 34, 30, 3, 256]

最初我读到你的问题是你想要颠倒的数字：

In [12]: sorted(A, key=lambda x: str(x)[::-1])
Out[12]: [30, 3, 34, 5, 256, 9]

Answer 2

以下代码回答了更新后的问题：“以一种连接排序后的数字将给出可能的最高数字的方式进行排序”。 这个想法是，如果最重要的数字相同并且长度不同，则如果在较长的数字中（较短的数字长度 + 1）数字大于或等于最高有效数字，则较长的数字比较短的数字“更大”。例如：30 3、10 3、3001 34、342

>>> def f(x, y):
...     if x == y:
...         return 0
...     xs = str(x)
...     ys = str(y)
...     for i in range(min(len(xs), len(ys))):
...         if xs[i] > ys[i]:
...             return 1
...         elif xs[i] < ys[i]:
...             return -1
...     if len(xs) > len(ys):
...         return 1 if xs[0] <= xs[len(ys)] else -1
...     return -1 if ys[0] <= ys[len(xs)] else 1
...
>>> A = [3, 30, 34, 256, 5, 9]
>>> B = [100,10,1]
>>> sorted(A, cmp=f, reverse=True)
[9, 5, 34, 3, 30, 256]
>>> sorted(B, cmp=f, reverse=True)
[1, 10, 100]

Answer 3

哦，您确实想要数字作为文本的字符串排序。好吧，如果您想要您描述的单位 -> 数十 -> 数百排序，就可以了：

# Repeatedly modulo 10 to get the rightmost digit
# (units, then tens, then hundreds) until the 
# digit where the two numbers differ. Compare those two digits.
>>> def f(x, y):
...     xr = x % 10
...     yr = y % 10
...     while x and y and xr == yr:
...         x, xr = divmod(x, 10)
...         y, yr = divmod(y, 10)
...     return cmp(xr, yr)
... 
>>> A = [3, 30, 34, 256, 5, 9]
>>> sorted(A, cmp=f)
[30, 3, 34, 5, 256, 9]

它不像您的示例输出那样排序，而是按单位排序 - 0、3、4、5、6、9。如果有任何单位相同的地方，它按十排序，等等。

>>> A = [3, 30, 34, 266, 256, 5, 9]
>>> sorted(A, cmp=f)
[30, 3, 34, 5, 256, 266, 9]

Answer 4

这是与之前发布的其他答案不同的版本：

import itertools

def produce_list(A):
   At = [str(x) for x in A]  # convert the items to str so we can join them
   result = 0
   for i in itertools.permutations(At):  # go through all permutations
      temp = int(''.join(i))
      if result < temp:   # find the biggest value of the combined numbers
          result = temp
          result_list = list(i)

   return [int(x) for x in result_list]  # return the list of ints

print produce_list([3, 30, 34, 256, 5, 9])
print produce_list([100, 1, 10])

它可能不是很有效（它会通过每一种组合），但它是我能得到的 Pythonic。