题目描述：
第一次提交:
class Solution:
def spiralOrder(self, matrix: List[List[int]]) -> List[int]:
j,x = 0,1
l = []
if matrix==[]:
return []
m = len(matrix)
n = len(matrix[0])
while x<=n*m:
for i in range(j,n-j):
l.append(matrix[j][i])
x += 1
for i in range(j+1,m-j):
l.append(matrix[i][n-j-1])
x += 1
if x <= n * m:
for i in range(n-j-2,j-1,-1):
l.append(matrix[m-j-1][i])
x += 1
for i in range(m-j-2,j,-1):
l.append(matrix[i][j])
x += 1
j += 1
return l
另：
class Solution:
def spiralOrder(self, matrix:[[int]]) -> [int]:
if not matrix: return []
l, r, t, b, res = 0, len(matrix[0]) - 1, 0, len(matrix) - 1, []
while True:
for i in range(l, r + 1): res.append(matrix[t][i]) # left to right
t += 1
if t > b: break
for i in range(t, b + 1): res.append(matrix[i][r]) # top to bottom
r -= 1
if l > r: break
for i in range(r, l - 1, -1): res.append(matrix[b][i]) # right to left
b -= 1
if t > b: break
for i in range(b, t - 1, -1): res.append(matrix[i][l]) # bottom to top
l += 1
if l > r: break
return res
笔记：
Python List extend()方法
描述
extend() 函数用于在列表末尾一次性追加另一个序列中的多个值（用新列表扩展原来的列表）。
语法
extend()方法语法：
list.extend(seq)
二、python中sorted和.sorted 、reversed和reverse的注意点
L=[1,2,3,4]
l1=[123,123,23]
if l1.sort() == L.reverse(): #这个判断式是恒等的，因为两个函数的返回值都是None（其实是无返回值）
print(1)
------------------------------------------------------------
a.sort()是对列表a进行原地修改，而且只能修改列表
而sorted（a）对字符串、列表、元组都能排序，该函数返回一个排序好的列表（都是列表！！）
------------------------------------------------------------
个人感觉reverse没什么diao用、当然原地修改还是要用reverse()的
因为对于字符串、列表、元组来说都可以用a[::-1]来取反
要注意a[::-1]返回的是一个逆转的列表、字符串、元组。并不是对a的原地修改
还有一种方法就是用.sort(reverse=1)来取反
-------------------------------------------------------------
.reverse()无返回值
使用reversed（）返回一个迭代器(迭代器的意思是只能通过循环来输出）
a = '321'
b = reversed(a)
print(b)
>>> <reversed object at 0x02E2B090>
显示的是返回了一个迭代器
迭代器用循环输出
for i in b:
print(i,end =' ')
>>> 1 2 3
为什么会和sorted不同呢
------------------------------------------------------------
用for i in reversed(a):
print(i)
发现数据输出竖着输出
改一个参数print(i,end=' ')将末尾的换行符\n换成‘ ’这样就不会自动换行了
三、python中zip()与zip(*)的用法解析
>>> a = [1,2,3]
>>> b = [4,5,6]
>>> c = [4,5,6,7,8]
>>> zipped = zip(a,b) # 打包为元组的列表
[(1, 4), (2, 5), (3, 6)]
>>> zip(a,c) # 元素个数与最短的列表一致
[(1, 4), (2, 5), (3, 6)]
>>> zip(*zipped) # 与 zip 相反，可理解为解压，为zip的逆过程，可用于矩阵的转置
[(1, 2, 3), (4, 5, 6)]
详见：
https://www.cnblogs.com/waltsmith/p/8029539.html
class Solution(object):
def spiralOrder(self, matrix):
"""
:type matrix: List[List[int]]
:rtype: List[int]
"""
# 取首行，去除首行后，对矩阵翻转来创建新的矩阵，
# 再递归直到新矩阵为[],退出并将取到的数据返回
ret = []
if matrix == []:
return ret
ret.extend(matrix[0]) # 上侧
new = [reversed(i) for i in matrix[1:]]
if new == []:
return ret
r = self.spiralOrder([i for i in zip(*new)])
ret.extend(r)
return ret
附：矩阵逆时针旋转代码：
matrix = [[1,2,3,4],[5,6,7,8],[9,10,11,12]]
new = [reversed(i) for i in matrix[:]]
new = [i for i in zip(*new)]
java通过两次翻转，实现原地旋转
class Solution {
public void rotate(int[][] matrix) {
int n = matrix.length;
for(int i = 0; i<n-1;i++){
for(int j = i+1;j<n;j++){
int tmp = matrix[i][j];
matrix[i][j] = matrix[j][i];
matrix[j][i] = tmp;
}
}
int mid = n>>1;
for(int i = 0;i<n;i++){
for(int j = 0;j<mid;j++){
int tmp = matrix[i][j];
matrix[i][j] = matrix[i][n -1 - j];
matrix[i][n-1-j] = tmp;
}
}
}
}
另：
class Solution:
def spiralOrder(self, matrix: List[List[int]]) -> List[int]:
res = []
while matrix:
res += matrix.pop(0)
matrix = list(zip(*matrix))[::-1]
return res