python基础：数组的倒序与隔位输出

我的代码：比较丑陋

import sys
n = sys.stdin.readline().strip()
n =int(n)
lines = list(map(int,sys.stdin.readline().strip().split(' ')))
for i in range (n):
    print(lines[n-1-i],end=' ')
print()
for x in range(n):
    if (x+1)%2 != 0:
        print(lines[x],end = ' ')

• print(lines[n - 1 - i], end=' ')：
  • print() 函数用于输出内容。在 Python 中，print() 函数默认会在输出内容的末尾添加一个换行符 \n，但可以通过 end 参数来改变这个行为。
  • end=' ' 表示在每次输出 lines[n - 1 - i] 之后，不添加换行符，而是添加一个空格。这样，循环中每次输出的元素就会以空格分隔，显示在同一行上。
• print()：这行代码的作用是在逆序输出结束后，输出一个换行符，使后续的输出能够从新的一行开始。

更优美的写法：

import sys

def process_array():
    n = int(sys.stdin.readline())
    arr = list(map(int, sys.stdin.readline().split()))
    
    # 倒序输出
    reversed_output = " ".join(map(str, arr[::-1]))
    print(reversed_output)
    
    # 正序数组中索引为奇数的元素输出
    odd_index_output = " ".join(map(str, arr[1::2]))
    print(odd_index_output)

if __name__ == "__main__":
    process_array()

代码解析：

1. 切片操作：

   • arr[::-1]：利用切片实现数组倒序，[::-1] 表示从后往前，步长为 -1，简洁高效。
   • arr[1::2]：获取索引为奇数的元素，1::2 表示从索引 1 开始，每隔 2 个元素取一个（即索引 1、3、5...）。

2. 字符串拼接：

   • join 方法：" ".join(map(str, ...)) 将整数列表转换为字符串列表，再用空格拼接成目标输出格式，比循环逐行打印更简洁。

3. 输入处理：

   • 通过 sys.stdin.readline() 读取输入，适配多行输入场景，代码结构清晰。

涉及知识点：

• 切片（Slice）：Python 序列（列表、字符串等）的高级操作，用于快速提取子序列。
• join 方法：字符串方法，用于将可迭代对象中的字符串元素按指定分隔符拼接。
• 类型转换：map(str, ...) 将整数列表转换为字符串列表，以便 join 处理。

一、数组（列表）的切片操作

切片是从列表中提取子序列的高效方式，语法为 list[start:end:step]，各参数含义：

• start：起始索引（包含），省略时默认从列表开头（索引 0）开始。
• end：结束索引（不包含），省略时默认到列表末尾。
• step：步长，省略时默认 1（依次取值）。

常见切片场景：

1. 基础切片

   arr = [10, 20, 30, 40, 50]
   print(arr[1:3])  # 输出 [20, 30]，提取索引 1 到 2 的元素
   print(arr[:3])   # 输出 [10, 20, 30]，从开头到索引 2
   print(arr[2:])   # 输出 [30, 40, 50]，从索引 2 到末尾
   

2. 负数索引切片

   arr = [10, 20, 30, 40, 50]
   print(arr[-3:-1])  # 输出 [30, 40]，倒数第 3 个到倒数第 2 个元素
   print(arr[-2:])    # 输出 [40, 50]，从倒数第 2 个到末尾
   

3. 带步长切片

   arr = [10, 20, 30, 40, 50]
   print(arr[::2])    # 输出 [10, 30, 50]，每隔 1 个元素取一个
   print(arr[1::2])   # 输出 [20, 40]，从索引 1 开始，每隔 1 个元素取一个
   print(arr[::-1])   # 输出 [50, 40, 30, 20, 10]，逆序列表
   

二、数组（列表）的其他常见操作

1. 元素增删改查

• 添加元素

  • append()：在列表末尾添加单个元素。

    arr = [1, 2]
    arr.append(3)  # arr 变为 [1, 2, 3]
    

  • insert()：在指定索引位置插入元素。

    arr = [1, 3]
    arr.insert(1, 2)  # 在索引 1 插入 2，arr 变为 [1, 2, 3]
    

  • extend()：合并另一个可迭代对象（如列表）到当前列表。

    arr1 = [1, 2]
    arr2 = [3, 4]
    arr1.extend(arr2)  # arr1 变为 [1, 2, 3, 4]
    

• 删除元素

  • del：根据索引删除元素。

    arr = [1, 2, 3]
    del arr[1]  # arr 变为 [1, 3]
    

  • pop()：删除并返回指定索引的元素（默认删除末尾元素）。

    arr = [1, 2, 3]
    print(arr.pop(1))  # 输出 2，arr 变为 [1, 3]
    

  • remove()：根据元素值删除（仅删除第一个匹配项）。

    arr = [1, 2, 2, 3]
    arr.remove(2)  # arr 变为 [1, 2, 3]
    

• 修改元素
  直接通过索引赋值。

  arr = [10, 20, 30]
  arr[1] = 25  # arr 变为 [10, 25, 30]
  

• 查询元素

  • index()：获取元素首次出现的索引。

    arr = [10, 20, 30]
    print(arr.index(20))  # 输出 1
    

  • count()：统计元素出现的次数。

    arr = [10, 20, 20, 30]
    print(arr.count(20))  # 输出 2
    

2. 排序与反转

• 排序

  • sort()：原地排序（修改原列表）。

    arr = [3, 1, 2]
    arr.sort()  # arr 变为 [1, 2, 3]
    arr.sort(reverse=True)  # 降序，arr 变为 [3, 2, 1]
    

  • sorted()：返回排序后的新列表，原列表不变。

    arr = [3, 1, 2]
    new_arr = sorted(arr)  # new_arr 是 [1, 2, 3]，arr 仍为 [3, 1, 2]
    

• 反转

  • reverse()：原地反转列表。

    arr = [1, 2, 3]
    arr.reverse()  # arr 变为 [3, 2, 1]
    

  • 切片反转：通过 [::-1] 生成反转后的新列表。

    arr = [1, 2, 3]
    reversed_arr = arr[::-1]  # reversed_arr 是 [3, 2, 1]，原 arr 不变

1. 负索引的含义

在 Python 里，列表除了支持正索引（从 0 开始），还支持负索引。负索引从列表的末尾开始计数，规则如下：

• -1 代表列表的最后一个元素。
• -2 代表列表的倒数第二个元素。
• 依此类推。

对于列表 arr = [10, 20, 30, 40, 50]，其元素对应的正索引和负索引如下：

2. 切片操作的规则

切片操作的语法是 list[start:end:step]，其中：

• start 是起始索引（包含该索引对应的元素）。
• end 是结束索引（不包含该索引对应的元素）。
• step 是步长，默认为 1。

当使用 arr[-3:-1] 时：

• start 为 -3，对应的元素是 30。
• end 为 -1，对应的元素是 50。
• 由于切片操作不包含结束索引对应的元素，所以不会取到 50。
• step 默认为 1，表示依次选取元素。

3. 代码执行过程

对于 arr[-3:-1]，从索引 -3（对应元素 30）开始，到索引 -1（对应元素 50）结束，但不包含索引 -1 对应的元素，所以最终选取的元素是 30 和 40，即输出 [30, 40]。