Python 倒车；“行”；列表中

我正在用python制作一个国际象棋引擎，所以我需要优化所有东西以尽可能快地运行。当黑白边被镜像时，我需要在正方形上显示一个分数列表

这是一个简化的列表：

A = [1,2,3,4,5,6,7,8,9]

让我们假设这个列表是一个矩阵：

A = [
1,2,3,
4,5,6,
7,8,9]

更改此列表中“行”的最快的方法是什么，因此最终结果将是：

A = [
7,8,9,
4,5,6,
1,2,3]

或写在同一行：

A = [7,8,9,4,5,6,1,2,3]

真正的列表有64个元素，我需要反转其中的8行。 这一逆转已经进行了数百万次，因此每一次改进都是值得欢迎的。 我正在寻找最快的方法。谢谢大家!

编辑：

我是这样做的，有没有更快的方法

A = [1,2,3,4,5,6,7,8,9]
A_size = len(A)
row_length = 3

for x in range(0,A_size,row_length):
    A.extend(A[A_size-row_length-x:A_size-x])
del A[0:A_size]
print(A)

---

探索一些选择：

numpy

如果与您的列表一起使用，则应该能够有效地执行此操作：

import numpy
A = [1,2,3,4,5,6,7,8,9]

m = numpy.array(A).reshape(3,3)
print(numpy.flip(m, axis=0))

同样，正如前面提到的，您可以使用索引来实现相同的功能：

print(numpy.array(A).reshape(3,3)[::-1,...])

numpy变体的效率出奇地低，可能是因为矩阵创建开销。因此，extend/del循环的纯Python替代方案可能是从生成器表达式创建一个新列表：

print([e for r in (A[A_size-row_length-x:A_size-x]
    for x in range(0,A_size,row_length)) for e in r])

另一个变体使用Python的“就地”切片替换，它似乎是迄今为止我列出的变体中速度最快的一个：

for x in range(0,A_size//2,row_length):
  A[x:x+row_length], A[A_size-row_length-x:A_size-x] = A[A_size-row_length-x:A_size-x], A[x:x+row_length]

然而，在我的本地测试中，最后一个变体仍然比原始extend/del变体慢约10%，而且更有趣的是，这种关系似乎是稳定的，即，当列表大小增加到50*50时，原始变体仍然是其中最快的

作为一个侧节点：如果它是一个选项，我会看到使用。我尝试了全索引就地替换：

    A[0],A[1],A[2],A[3],A[4],A[5],A[6],A[7],A[8],A[9],A[10],A[11],A[12],A[13],A[14],A[15],A[16],A[17],A[18],A[19],A[20],A[21],A[22],A[23],A[24],A[25],A[26],A[27],A[28],A[29],A[30],A[31],A[32],A[33],A[34],A[35],A[36],A[37],A[38],A[39],A[40],A[41],A[42],A[43],A[44],A[45],A[46],A[47],A[48],A[49],A[50],A[51],A[52],A[53],A[54],A[55],A[56],A[57],A[58],A[59],A[60],A[61],A[62],A[63] = A[56],A[57],A[58],A[59],A[60],A[61],A[62],A[63],A[48],A[49],A[50],A[51],A[52],A[53],A[54],A[55],A[40],A[41],A[42],A[43],A[44],A[45],A[46],A[47],A[32],A[33],A[34],A[35],A[36],A[37],A[38],A[39],A[24],A[25],A[26],A[27],A[28],A[29],A[30],A[31],A[16],A[17],A[18],A[19],A[20],A[21],A[22],A[23],A[8],A[9],A[10],A[11],A[12],A[13],A[14],A[15],A[0],A[1],A[2],A[3],A[4],A[5],A[6],A[7]

---

虽然这比上面使用标准Python3的slice replacement变体稍微慢一点，但使用PyPy，它的性能比原始的extend/del循环高出约2.6倍。

探索一些选项：

numpy

如果与您的列表一起使用，则应该能够有效地执行此操作：

import numpy
A = [1,2,3,4,5,6,7,8,9]

m = numpy.array(A).reshape(3,3)
print(numpy.flip(m, axis=0))

同样，正如前面提到的，您可以使用索引来实现相同的功能：

print(numpy.array(A).reshape(3,3)[::-1,...])

numpy变体的效率出奇地低，可能是因为矩阵创建开销。因此，extend/del循环的纯Python替代方案可能是从生成器表达式创建一个新列表：

print([e for r in (A[A_size-row_length-x:A_size-x]
    for x in range(0,A_size,row_length)) for e in r])

另一个变体使用Python的“就地”切片替换，它似乎是迄今为止我列出的变体中速度最快的一个：

for x in range(0,A_size//2,row_length):
  A[x:x+row_length], A[A_size-row_length-x:A_size-x] = A[A_size-row_length-x:A_size-x], A[x:x+row_length]

然而，在我的本地测试中，最后一个变体仍然比原始extend/del变体慢约10%，而且更有趣的是，这种关系似乎是稳定的，即，当列表大小增加到50*50时，原始变体仍然是其中最快的

作为一个侧节点：如果它是一个选项，我会看到使用。我尝试了全索引就地替换：

    A[0],A[1],A[2],A[3],A[4],A[5],A[6],A[7],A[8],A[9],A[10],A[11],A[12],A[13],A[14],A[15],A[16],A[17],A[18],A[19],A[20],A[21],A[22],A[23],A[24],A[25],A[26],A[27],A[28],A[29],A[30],A[31],A[32],A[33],A[34],A[35],A[36],A[37],A[38],A[39],A[40],A[41],A[42],A[43],A[44],A[45],A[46],A[47],A[48],A[49],A[50],A[51],A[52],A[53],A[54],A[55],A[56],A[57],A[58],A[59],A[60],A[61],A[62],A[63] = A[56],A[57],A[58],A[59],A[60],A[61],A[62],A[63],A[48],A[49],A[50],A[51],A[52],A[53],A[54],A[55],A[40],A[41],A[42],A[43],A[44],A[45],A[46],A[47],A[32],A[33],A[34],A[35],A[36],A[37],A[38],A[39],A[24],A[25],A[26],A[27],A[28],A[29],A[30],A[31],A[16],A[17],A[18],A[19],A[20],A[21],A[22],A[23],A[8],A[9],A[10],A[11],A[12],A[13],A[14],A[15],A[0],A[1],A[2],A[3],A[4],A[5],A[6],A[7]

---

虽然这比上面使用标准Python3的切片替换变体稍微慢一点，但使用PyPy时，它的性能比原始的extend/del循环高出约2.6倍。

当您想要转换列表并将其反转为矩阵时，可以使用以下代码段

def chunk(lst, n):
    for i in range(0, len(lst), n):
        yield lst[i:i + n]


a = [1, 2, 3, 4, 5, 6, 7, 8, 9]

b = list(chunk(a, 3))
b.reverse()
b = sum(b, [])

print(b)

# [7, 8, 9, 4, 5, 6, 1, 2, 3]

使用二维数组作为起点时，此任务要容易得多：

a = [[1, 2, 3], [4, 5, 6], [7, 8, 9]]

a.reverse()    

print(a)

# [[7, 8, 9], [4, 5, 6], [1, 2, 3]]

---

当您想要转换列表并将其反转为矩阵时，可以使用以下代码段

def chunk(lst, n):
    for i in range(0, len(lst), n):
        yield lst[i:i + n]


a = [1, 2, 3, 4, 5, 6, 7, 8, 9]

b = list(chunk(a, 3))
b.reverse()
b = sum(b, [])

print(b)

# [7, 8, 9, 4, 5, 6, 1, 2, 3]

使用二维数组作为起点时，此任务要容易得多：

a = [[1, 2, 3], [4, 5, 6], [7, 8, 9]]

a.reverse()    

print(a)

# [[7, 8, 9], [4, 5, 6], [1, 2, 3]]

---

尝试使用生成器从列表末尾向后分块到列表开头：

from itertools import chain

A = [1,2,3,4,5,6,7,8,9]

def chunk(lst, step):
    start = len(lst)
    for i in range(start, -1, -step):
        yield lst[i-step:i]
    yield lst[0:i]  #any remaning bit

l = list(chain.from_iterable(chunk(A, 3)))

print(l)

输出：

[7, 8, 9, 4, 5, 6, 1, 2, 3]

---

尝试使用生成器从列表末尾向后分块到列表开头：

from itertools import chain

A = [1,2,3,4,5,6,7,8,9]

def chunk(lst, step):
    start = len(lst)
    for i in range(start, -1, -step):
        yield lst[i-step:i]
    yield lst[0:i]  #any remaning bit

l = list(chain.from_iterable(chunk(A, 3)))

print(l)

输出：

[7, 8, 9, 4, 5, 6, 1, 2, 3]

---

---

你想出什么办法了吗？Numpy为各种矩阵操作优化了函数。我认为使用一维数组不是矩阵是值得的。我知道列表不是矩阵，我从来没有说过为什么不使用二维数组？你有什么办法吗？Numpy为各种矩阵操作优化了函数。我认为使用一维数组不是矩阵是值得的。我知道列表不是矩阵，我从来没有说过为什么不使用二维数组？谢谢你的回答，在我的电脑上，100万次迭代需要3.94秒，我的版本花了1.11秒第二个版本花了1.44秒来测试测量，谢谢你的反馈。谢谢你的时间，你的第三个代码花了1.23秒谢谢那迷人的兔子洞。从未想过简单的扩展/删除会如此高效。感谢您的回答，在我的电脑上，100万次迭代需要3.94秒，我的版本需要1.11秒。第二个版本需要1.44秒来测试测量，感谢您的反馈。谢谢您的时间，你的第三个代码需要1.23秒来完成这个迷人的兔子洞。从未想过简单的扩展/删除会如此高效。谢谢，对于100万次迭代，您的版本需要1.21秒，我的版本需要1.11秒谢谢，对于100万次迭代，您的版本需要1.21秒，我的版本需要1.11秒谢谢您的回答，对于100万次迭代，您的版本需要1.32秒，我的需要1分钟。11@BillieJoe真有趣！我已经稍微更新了上面的代码，因为开始和结束都不需要传递。谢谢你的时间，但速度还是比较慢，现在我有1.36秒的时间来解决最后一个问题谢谢你的回答，一百万次迭代你的版本需要1.32秒，我的版本需要1.32秒。11@BillieJoe真有趣！我已经稍微更新了上面的代码，因为开始和结束都不需要传入。感谢您的时间，但速度仍然较慢，现在我有1.36秒的时间来完成最后一个解决方案