Python列表(list)反序(降序)的7种实现方式

Python列表(list)反序(降序)的实现方式:原址反序,list.reverse()、list.sort()、全数组遍历、1/2数组遍历;新生成列表,resersed()、sorted()、负步长切片[::-1]。共七种方式,可以实现列表反序。


(本文获得优快云质量评分【91】)

【学习的细节是欢悦的历程】


  自学并不是什么神秘的东西,一个人一辈子自学的时间总是比在学校学习的时间长,没有老师的时候总是比有老师的时候多。
            —— 华罗庚


等风来,不如追风去……


Python列表原址操作、新生成列表
列表反序的7种实现方式
(列表原址操作4种、新生成列表3种,共计7种)


本文质量分:

91
本文地址: https://blog.youkuaiyun.com/m0_57158496/article/details/128271700

优快云质量分查询入口:http://www.youkuaiyun.com/qc



◆ 数组反序的7种方式

1、试炼数组


lis = list('abcdefghijklmnopqrstuvwxyz')
print(f"\n\n序列:{lis}\n")

序列:[‘a’, ‘b’, ‘c’, ‘d’, ‘e’, ‘f’, ‘g’, ‘h’, ‘i’, ‘j’, ‘k’, ‘l’, ‘m’, ‘n’, ‘o’, ‘p’, ‘q’, ‘r’, ‘s’, ‘t’, ‘u’, ‘v’, ‘w’, ‘x’, ‘y’, ‘z’]


回页目录

2、list方法

2.1 list.reverse()

  可以利用列表方法,直接反序。reverse方法无返回值,原址操作列表。


lis = list('abcdefghijklmnopqrstuvwxyz')
lis.reverse() # reverse方法无返回值,原址反序操作列表。
print(f"\n\n序列:{lis}\n\n反序:{lis}\n")

序列:[‘a’, ‘b’, ‘c’, ‘d’, ‘e’, ‘f’, ‘g’, ‘h’, ‘i’, ‘j’, ‘k’, ‘l’, ‘m’, ‘n’, ‘o’, ‘p’, ‘q’, ‘r’, ‘s’, ‘t’, ‘u’, ‘v’, ‘w’, ‘x’, ‘y’, ‘z’]

反序:[‘z’, ‘y’, ‘x’, ‘w’, ‘v’, ‘u’, ‘t’, ‘s’, ‘r’, ‘q’, ‘p’, ‘o’, ‘n’, ‘m’, ‘l’, ‘k’, ‘j’, ‘i’, ‘h’, ‘g’, ‘f’, ‘e’, ‘d’, ‘c’, ‘b’, ‘a’]


回页目录

2.2 list.sort()

  sort()方法无返回值,原址排序操作列表。其reverse参数默认=False,正序排序;令其=True,反序(降序)排序。


lis = list('abcdefghijklmnopqrstuvwxyz')
lis.sort(reverse=True) # sort方法无返回值,原址排序操作列表。
print(f"\n\n序列:{lis}\n\n反序:{lis}\n")

序列:[‘a’, ‘b’, ‘c’, ‘d’, ‘e’, ‘f’, ‘g’, ‘h’, ‘i’, ‘j’, ‘k’, ‘l’, ‘m’, ‘n’, ‘o’, ‘p’, ‘q’, ‘r’, ‘s’, ‘t’, ‘u’, ‘v’, ‘w’, ‘x’, ‘y’, ‘z’]

反序:[‘z’, ‘y’, ‘x’, ‘w’, ‘v’, ‘u’, ‘t’, ‘s’, ‘r’, ‘q’, ‘p’, ‘o’, ‘n’, ‘m’, ‘l’, ‘k’, ‘j’, ‘i’, ‘h’, ‘g’, ‘f’, ‘e’, ‘d’, ‘c’, ‘b’, ‘a’]


回页目录

3、轮询(遍历)

3.1 遍历整列表

  用list.pop()模拟栈弹出,将弹出元素用list.insert()方法依次插入列表0~n-1位置,实现反序。


lis = list('abcdefghijklmnopqrstuvwxyz')

for i in range(len(lis)):
    lis.insert(i, lis.pop())

print(f"\n\n序列:{lis}\n\n反序:{lis}\n")

序列:[‘a’, ‘b’, ‘c’, ‘d’, ‘e’, ‘f’, ‘g’, ‘h’, ‘i’, ‘j’, ‘k’, ‘l’, ‘m’, ‘n’, ‘o’, ‘p’, ‘q’, ‘r’, ‘s’, ‘t’, ‘u’, ‘v’, ‘w’, ‘x’, ‘y’, ‘z’]

反序:[‘z’, ‘y’, ‘x’, ‘w’, ‘v’, ‘u’, ‘t’, ‘s’, ‘r’, ‘q’, ‘p’, ‘o’, ‘n’, ‘m’, ‘l’, ‘k’, ‘j’, ‘i’, ‘h’, ‘g’, ‘f’, ‘e’, ‘d’, ‘c’, ‘b’, ‘a’]

3.2 遍历数组1/2元素

  从列表中间开始,依次对调前后元素实现反序。这要区分处理列表元素为奇偶的情况:奇,中间位置只有一个元素,不;偶,对调从处中间的两个元素开始对调。

a. 奇数个元素数组

  数组元素总数为奇数,中间位置n=int(len(lis)/2)m,只有一个元素,不用对调。对调从下标n-1、n+1开始对调。


lis = list('abcdefghijklmnopqrstuvwxy')
n = int(len(lis)/2) # 计算中间位置。

for i in range(n+1):
    print(lis[n-i], lis[1, n+i])
    lis[n-i], lis[n+i] = lis[n+i], lis[n-i]

print(f"\n\n序列:{lis}\n\n反序:{lis}\n")

l n
k o
j p
i q
h r
g s
f t
e u
d v
c w
b x
a y

序列:[‘y’, ‘x’, ‘w’, ‘v’, ‘u’, ‘t’, ‘s’, ‘r’, ‘q’, ‘p’, ‘o’, ‘n’, ‘m’, ‘l’, ‘k’, ‘j’, ‘i’, ‘h’, ‘g’, ‘f’, ‘e’, ‘d’, ‘c’, ‘b’, ‘a’]

反序:[‘y’, ‘x’, ‘w’, ‘v’, ‘u’, ‘t’, ‘s’, ‘r’, ‘q’, ‘p’, ‘o’, ‘n’, ‘m’, ‘l’, ‘k’, ‘j’, ‘i’, ‘h’, ‘g’, ‘f’, ‘e’, ‘d’, ‘c’, ‘b’, ‘a’]

b. 偶数个元素数组

  数组元素总数为偶数,中间位置n=int(len(lis)/2)±1之间,没有元素。对调从下标n-0、n+0开始对调。


n = int(len(lis)/2) - 1 # 计算中间位置。

lis = list('abcdefghijklmnopqrstuvwxyz')
n = int(len(lis)/2) - 1 # 计算中间位置。

for i in range(n+1):
    print(lis[n-i], lis[n+i+1])
    lis[n-i], lis[n+i+1] = lis[n+i+1], lis[n-i]

print(f"\n\n序列:{lis}\n\n反序:{lis}\n")

m n
l o
k p
j q
i r
h s
g t
f u
e v
d w
c x
b y
a z

序列:[‘a’, ‘b’, ‘c’, ‘d’, ‘e’, ‘f’, ‘g’, ‘h’, ‘i’, ‘j’, ‘k’, ‘l’, ‘m’, ‘n’, ‘o’, ‘p’, ‘q’, ‘r’, ‘s’, ‘t’, ‘u’, ‘v’, ‘w’, ‘x’, ‘y’, ‘z’]

反序:[‘z’, ‘y’, ‘x’, ‘w’, ‘v’, ‘u’, ‘t’, ‘s’, ‘r’, ‘q’, ‘p’, ‘o’, ‘n’, ‘m’, ‘l’, ‘k’, ‘j’, ‘i’, ‘h’, ‘g’, ‘f’, ‘e’, ‘d’, ‘c’, ‘b’, ‘a’]


回页目录

4、新生成列表实现反序

4.1 负步长切片

  直接用[::-1]切片原列表,生成的新列表即已反序。
  了解“切片”更多知识点,可以点击我的学习笔记“Python之魔幻切片”。


lis = list('abcdefghijklmnopqrstuvwxyz')
print(f"\n\n序列:{lis}\n\n反序:{lis[::-1]}\n")

序列:[‘a’, ‘b’, ‘c’, ‘d’, ‘e’, ‘f’, ‘g’, ‘h’, ‘i’, ‘j’, ‘k’, ‘l’, ‘m’, ‘n’, ‘o’, ‘p’, ‘q’, ‘r’, ‘s’, ‘t’, ‘u’, ‘v’, ‘w’, ‘x’, ‘y’, ‘z’]

反序:[‘z’, ‘y’, ‘x’, ‘w’, ‘v’, ‘u’, ‘t’, ‘s’, ‘r’, ‘q’, ‘p’, ‘o’, ‘n’, ‘m’, ‘l’, ‘k’, ‘j’, ‘i’, ‘h’, ‘g’, ‘f’, ‘e’, ‘d’, ‘c’, ‘b’, ‘a’]

4.2 reversed()

  效果同list.reverse()方法,不同的是reversed()函数不是原址操作列表,而是返回一个新列表。


lis = list('abcdefghijklmnopqrstuvwxyz')
print(f"\n返回类型:{type(reversed(lis))}\n")
print(f"\n\n序列:{lis}\n\n反序:{list(reversed(lis))}\n")

返回类型:<class ‘list_reverseiterator’>

序列:[‘a’, ‘b’, ‘c’, ‘d’, ‘e’, ‘f’, ‘g’, ‘h’, ‘i’, ‘j’, ‘k’, ‘l’, ‘m’, ‘n’, ‘o’, ‘p’, ‘q’, ‘r’, ‘s’, ‘t’, ‘u’, ‘v’, ‘w’, ‘x’, ‘y’, ‘z’]

反序:[‘z’, ‘y’, ‘x’, ‘w’, ‘v’, ‘u’, ‘t’, ‘s’, ‘r’, ‘q’, ‘p’, ‘o’, ‘n’, ‘m’, ‘l’, ‘k’, ‘j’, ‘i’, ‘h’, ‘g’, ‘f’, ‘e’, ‘d’, ‘c’, ‘b’, ‘a’]

4.3 sorted()

  效果同list.sort()方法,不同的是sorted()函数不是原址操作列表,而是返回一个新列表。


lis = list('abcdefghijklmnopqrstuvwxyz')
print(f"\n返回类型:{type(sorted(lis, reverse=True))}\n")
print(f"\n\n序列:{lis}\n\n反序:{sorted(lis, reverse=True)}\n")

返回类型:<class ‘list’>

序列:[‘a’, ‘b’, ‘c’, ‘d’, ‘e’, ‘f’, ‘g’, ‘h’, ‘i’, ‘j’, ‘k’, ‘l’, ‘m’, ‘n’, ‘o’, ‘p’, ‘q’, ‘r’, ‘s’, ‘t’, ‘u’, ‘v’, ‘w’, ‘x’, ‘y’, ‘z’]

反序:[‘z’, ‘y’, ‘x’, ‘w’, ‘v’, ‘u’, ‘t’, ‘s’, ‘r’, ‘q’, ‘p’, ‘o’, ‘n’, ‘m’, ‘l’, ‘k’, ‘j’, ‘i’, ‘h’, ‘g’, ‘f’, ‘e’, ‘d’, ‘c’, ‘b’, ‘a’]


回页目录

5、完整源码

(源码较长,点此跳过源码)
#!/sur/bin/nve 
# coding: utf-8 

# reverse()
lis = list('abcdefghijklmnopqrstuvwxyz')
lis.reverse() # reverse方法无返回值,原址反序操作列表。
print(f"\n\n序列:{lis}\n\n反序:{lis}\n")
input(' reverse()方法 '.center(48, '~'))

# sort()
lis = list('abcdefghijklmnopqrstuvwxyz')
lis.sort(reverse=True) # sort方法无返回值,原址排序操作列表。
print(f"\n\n序列:{lis}\n\n反序:{lis}\n")
input(' sort()方法 '.center(48, '~'))

# for all
lis = list('abcdefghijklmnopqrstuvwxyz')

for i in range(len(lis)):
    lis.insert(i, lis.pop())

print(f"\n\n序列:{lis}\n\n反序:{lis}\n")
input(' 遍历数组所有元素 '.center(42, '~'))

# for 1/2,奇数个元素数组
lis = list('abcdefghijklmnopqrstuvwxy')
n = int(len(lis)/2) # 计算中间位置。

for i in range(1, n+1):
    print(lis[n-i], lis[n+i])
    lis[n-i], lis[n+i] = lis[n+i], lis[n-i]

print(f"\n\n序列:{lis}\n\n反序:{lis}\n")
input(' 遍历数组1/2元素(总元素为奇数) '.center(38, '~'))

# for all,偶数个元素数组。
lis = list('abcdefghijklmnopqrstuvwxyz')
n = int(len(lis)/2) - 1 # 计算中间位置。

for i in range(n+1):
    print(lis[n-i], lis[n+i+1])
    lis[n-i], lis[n+i+1] = lis[n+i+1], lis[n-i]

print(f"\n\n序列:{lis}\n\n反序:{lis}\n")
input(' 遍历数组1/2元素(总元素为偶数) '.center(38, '~'))


# 新生成列表,负步长切片。
lis = list('abcdefghijklmnopqrstuvwxyz')
print(f"\n\n序列:{lis}\n\n反序:{lis[::-1]}\n")
input(' 负步长切片 '.center(45, '~'))

# 新生成列表,resersed()。
lis = list('abcdefghijklmnopqrstuvwxyz')
print(f"\n返回类型:{type(reversed(lis))}\n")
print(f"\n\n序列:{lis}\n\n反序:{list(reversed(lis))}\n")
input(' reversed()函数 '.center(48, '~'))

# 新生成列表,storted()。
lis = list('abcdefghijklmnopqrstuvwxyz')
print(f"\n返回类型:{type(sorted(lis, reverse=True))}\n")
print(f"\n\n序列:{lis}\n\n反序:{sorted(lis, reverse=True)}\n")
input(' sorted()函数 '.center(48, '~'))


回页首

__上一篇:__ 代码实现“约瑟夫环”百科词条中的例子故事

__下一篇:__ 

我的HOT博:

    <think>嗯,用户问的是如何在Python中对列表进行反序操作。首先,我需要回忆一下Python列表反转的几种方法。常用的方法可能有使用reverse()方法,或者切片操作,还有reversed()函数。 记得reverse()方法是原地反转,会直接修改原列表,而不会返回新列表。比如,如果用户有一个列表a,调用a.reverse()之后,a本身就会被反转。这个方法比较直接,但需要注意它会改变原列表的内容。 然后是切片操作,比如list[::-1],这种方法会生成一个反转后的新列表,原列表保持不变。这可能适合需要保留原列表的情况。不过切片操作对于刚学Python的人来说可能有点难记,特别是步长设置为-1的时候。 还有reversed()函数,它返回的是一个迭代器,而不是列表,所以如果需要得到列表的话,可能还需要用list()转换一下。比如,list(reversed(list))。这个方法的好处是不改变原列表,同时适用于其他可迭代对象,不仅仅是列表。 接下来,我需要确认这些方法是否正确,有没有其他需要注意的地方。比如,reverse()方法没有返回值,如果用户尝试赋值的话,可能会得到None,这是一个常见的错误点。另外,切片操作的效率如何?对于大列表来说,生成新列表可能会有内存上的考虑,但通常Python列表操作效率还是不错的。 用户可能的需求是什么?他们可能只是想反转列表,但不知道哪种方法最合适。比如,是否需要原地反转还是保留原列表。或者他们可能是在处理其他序列类型,比如字符串或元组,这时候可能需要用到reversed()函数或者切片,因为reverse()方法是列表独有的。 另外,根据提供的引用资料,用户提到了一些反序的方法,比如list.reverse()和for循环中的处理,还有使用range倒序索引。比如引用[1]中的例子,提到了两种方法:一种是使用list.reverse()并在try/finally块中恢复,另一种是使用range生成倒序索引。这可能是一个需要注意的地方,特别是在迭代时临时反转的情况。 还有引用[3]中的例子,使用了切片data[::-1]来反转字符串内容,这种方法同样适用于列表。所以切片方法是一个通用的解决方案,适用于多种序列类型。 总结一下,我应该列出这几种方法,并说明它们的区别和使用场景。比如: 1. list.reverse():原地反转,修改原列表,无返回值。 2. 切片list[::-1]:生成新列表,原列表不变。 3. reversed()函数:返回迭代器,需要转换为列表,原列表不变。 4. 循环倒序索引:比如for i in range(len(list)-1, -1, -1),虽然比较原始,但在某些情况下可能有用。 还需要注意这些方法的时间复杂度和空间复杂度。reverse()和切片的时间复杂度都是O(n),但切片需要额外的空间。对于非常大的列表,可能需要考虑内存使用情况。 用户可能需要具体的例子来理解,所以每个方法都应该给出示例代码,比如: 示例1: a = [1,2,3] a.reverse() print(a) # 输出[3,2,1] 示例2: b = a[::-1] 示例3: c = list(reversed(a)) 此外,引用中的代码示例可能有助于增强答案的可信度,比如引用[1]中的reverse()和range方法,引用[3]中的切片方法。 可能的相关问题包括性能比较、不同方法的适用场景、如何选择合适的方法等。比如,用户可能想知道哪种方法更快,或者在处理不可变序列时应该用什么方法。 最后,确保回答结构清晰,分点说明,并给出代码示例。同时,生成的相关问题要围绕这个主题,比如优化方法、性能分析、应用场景等。</think>在Python中对列表进行反序操作有以下几种常见方法,具体选择取决于是否需要修改原列表或生成新列表: --- ### 方法1:`list.reverse()` 原地反转 直接调用列表的`reverse()`方法,会**直接修改原列表**且无返回值。 ```python a = [1, 2, 3, 4] a.reverse() print(a) # 输出 [4, 3, 2, 1] ``` --- ### 方法2:切片操作 `[::-1]` 生成新列表 通过切片语法创建反转后的新列表,**原列表保持不变**。 ```python a = [1, 2, 3, 4] b = a[::-1] print(b) # 输出 [4, 3, 2, 1] print(a) # 输出 [1, 2, 3, 4] ``` --- ### 方法3:`reversed()` 函数返回迭代器 使用内置函数`reversed()`生成反向迭代器,需通过`list()`转换为列表,**原列表不变**。 ```python a = [1, 2, 3, 4] c = list(reversed(a)) print(c) # 输出 [4, 3, 2, 1] ``` --- ### 方法4:反向索引循环(通用方法) 通过倒序索引遍历原列表,适用于非列表的序列类型(如字符串、元组)[^1]: ```python a = [1, 2, 3, 4] for i in range(len(a)-1, -1, -1): print(a[i], end=' ') # 输出 4 3 2 1 ``` --- ### 方法对比 | 方法 | 是否修改原列表 | 时间复杂度 | 空间复杂度 | 适用场景 | |--------------------|----------------|------------|------------|-------------------------| | `list.reverse()` | 是 | $O(n)$ | $O(1)$ | 需要原地修改 | | 切片 `[::-1]` | 否 | $O(n)$ | $O(n)$ | 生成新列表 | | `reversed()`+`list`| 否 | $O(n)$ | $O(n)$ | 需迭代器或保留原列表 | | 反向索引循环 | 否 | $O(n)$ | $O(1)$ | 非列表序列或需逐项处理 | --- ### 应用场景 - 原地修改:优先使用`list.reverse()`(如内存受限场景)[^1] - 生成新列表:推荐切片操作(代码简洁) - 迭代处理:使用`reversed()`避免内存占用(如处理大型数据集) ---
    评论 9
    添加红包

    请填写红包祝福语或标题

    红包个数最小为10个

    红包金额最低5元

    当前余额3.43前往充值 >
    需支付:10.00
    成就一亿技术人!
    领取后你会自动成为博主和红包主的粉丝 规则
    hope_wisdom
    发出的红包

    打赏作者

    梦幻精灵_cq

    你的鼓励将是我创作的最大动力

    ¥1 ¥2 ¥4 ¥6 ¥10 ¥20
    扫码支付:¥1
    获取中
    扫码支付

    您的余额不足,请更换扫码支付或充值

    打赏作者

    实付
    使用余额支付
    点击重新获取
    扫码支付
    钱包余额 0

    抵扣说明:

    1.余额是钱包充值的虚拟货币,按照1:1的比例进行支付金额的抵扣。
    2.余额无法直接购买下载,可以购买VIP、付费专栏及课程。

    余额充值