【卡码网Python基础课 6.数组的倒序与隔位输出】

---

题目描述

题目描述：
给定一个整数数组，编写一个程序实现以下功能：
1.将输入的整数数组倒序输出，每个数之间用空格分隔。
2. 从正序数组中，每隔一个单位（即索引为奇数的元素），输出其值，同样用空格分隔。

输入描述：
第一行包含一个整数 n，表示数组的长度。
接下来一行包含 n 个整数，表示数组的元素。

输出描述：
首先输出倒序排列的数组元素，然后输出正序数组中每隔一个单位的元素。

一、数组

数组其实就是“一组数据”，是一种用于存储相同数据类型的元素的数据结构。

数据结构的概念理解起来比较抽象，它表示了数据在计算中被组织和存储的形式，而数组呢就是一组按照一定次序排列的数值，数组中的每一个变量被称为元素，比如下图中就是数组的存储形式：

数组中的元素必须是相同的数据类型，也就是说假如创建了一个整数数组，数组里就不能有其他数据类型的存在。

每种数据结构都具有一些特点，我们假设用“班级”这种组织的形式来简单阐述数组的特点：

(1):固定大小：数组一旦声明，其大小通常是固定的，不能在运行时动态更改。就好比开设了一个30人的班级，班级大小已经固定，不能再改变班级的规模。
(2):相同数据类型： 数组中的所有元素必须具有相同的数据类型，假设这个班都是男生或者都是女生，只能有一种性别存在。
(3):连续存储： 数组的元素在内存中是连续存储的，班级里的同学按照顺序就坐，中间没有留空位。
(4):下标访问： 数组中的元素通过下标（索引）进行访问，每个人都有一个学号，学号就是自己的座位，这个学号被称为索引，但是数组里的索引是从0开始的，也就是说，第一个元素的索引是0，第二个元素的索引是1，依次类推。

二、列表

在大多数编程语言中，都有数组的概念，但是在Python中，使用列表替换了数组，相比于数组，列表更加灵活，可以存储一系列有序的元素，可以包含不同类型的数据（如整数、字符串、甚至其他列表），并且支持添加、移除和其他操作。

1.创建列表

使用方括号 []或使用 list() 创建一个列表。list()函数可以将其他可迭代对象转换成列表，比如字符串。

my_list = [1, 2, 3, 4, 5]
my_list = list()

my_string = "hello"
# 将字符串转为列表
string_list = list(my_string)

2.访问列表元素

使用索引来访问列表中的元素，但是需要注意，索引是从 0 开始的，0 代表第一个元素，1代表第2个元素。

my_list = [1, 2, 3, 4, 5]
first_element = my_list[0]  # 访问第一个元素，值为1

3.修改列表元素

可以通过索引来修改列表中的元素。

my_list = [1, 2, 3, 4, 5]
my_list[0] = 10  # 修改第1个元素的值为10

4.列表长度

可以使用 len() 函数来获取列表的长度，即列表中元素的个数。

my_list = [1, 2, 3, 4, 5]
length = len(my_list)  # 获取列表的长度，值为5

5.其他操作

此外Python还提供了许多用于操作列表的方法，例如添加元素、删除元素、排序等。常见的方法有以下几个：
append(value)：将新的元素添加到列表的末尾。

my_list = [1, 2, 3, 4, 5]
my_list.append(6) # my_list现在是[1,2,3,4,5,6]

insert(index, value): 在指定位置插入元素。

my_list = [1, 2, 3, 4, 5]
my_list.insert(0, 6)  # 在索引0处插入6, 现在是 [6,1, 2, 3, 4, 5]

remove(value): 移除值为value的元素，但是如果有多个时，只删除第一个

my_list = [1, 2, 2, 3,4,5]
my_list.remove(2)  # 删除第一个值为2的元素, 现在是 [1, 2, 3, 4, 5]

pop(index): 删除并返回指定索引index位置的元素。

my_list = [1, 2, 3, 4, 5]
popped_element = my_list.pop(1)  # 删除并返回索引1处的元素,现在是 [1, 3, 4, 5] popped_element 是 2

index(value): 返回指定值value的索引位置, 如果有多个时，返回第一个。

my_list = [1, 2, 3, 4, 5, 2]
element_index = my_list.index(2)  # 返回2的第一个索引位置, 即 索引 1

sort(): 按照升序排序列表。

my_list = [3, 1, 2, 5, 4]
my_list.sort()  # 按升序排序, 现在是 [1, 2, 3, 4, 5]

reverse(): 反转列表的顺序。

my_list = [1, 2, 3, 4, 5]
my_list.reverse()  # 反转列表元素的顺序, 现在是 [5, 4, 3, 2, 1]

二、切片

在Python中，还可以使用切片来获取列表中的一小部分元素，相当于列表的子列表。

从字面含义上来理解，切片是对列表的一个连续片段的引用，就好像列表从中间的某个部分到另外一个部分切了两刀，从而拿到列表的一部分。

my_list(startIndex: endIndex: step)

startIndex：切片开始的索引，包含此索引的元素。如果省略，默认为序列的开始。
endIndex：切片结束的索引，不包含此索引的元素。如果省略，默认为序列的结束。
step：步长，决定选取元素的间隔。如果省略，默认为1

如果开始位置和结束位置都传递，表示从切片的startIndex位置切到endIndex所在的位置
如果不传递开始位置，即list[ : endIndex]，表示从列表的开头切到endIndex所在的位置
如果不传递结束位置，即list[startIndex : ],表明从列表的startIndex位置切到末尾
如果开始位置和结束位置都不传递，即list[ : ], 表明从列表的开头切到末尾，相当于整个列表。

比如下面的示例：

my_list = [1, 2, 3, 4, 5, 6, 7]

# 从索引1到索引5，不包括索引5的元素
sublist = my_list[1:5]
# sublist 现在是 [2,3,4,5]

# 从索引1开始到末尾
sublist = my_list[1:]
# sublist 现在是 [2, 3, 4, 5, 6, 7]

# 从头开始到索引3，不包括索引3的元素
sublist = my_list[:3]
# sublist 现在是 [1, 2, 3]

# 使用步长，从索引0开始，每隔2个元素取一个
sublist = my_list[0::2]
# sublist 现在是 [1，3，5，7]

此外，还可以使用负数索引，-1 表示最后一个元素，-2表示倒数第二个元素，依次类推。

sublist = my_list[-2: ] # 倒数第二个元素一直到列表的末尾
# sublist现在是[6, 7]

sublist = my_list[-3:-1]  # 倒数第三个到倒数第二个元素，不包括最后一个元素
# sublist现在是[5, 6]

三、倒序输出数组

回归到题目，第一个要求将输入的整数数组倒序输出，每个数之间用空格分隔，首先读取数组的长度n

n = int(input())  # 输入数组长度

然后读取输入的包含空格的整数，将其转换成列表，首先需要使用split()将输入字符串分割成字符列表，然后使用map()转换成整数，最后转换成列表。

nums = list(map(int, input().split()))  # 输入数组元素，将其分割并转换为整数列表

此时列表的长度为n， 倒序输出列表，即从列表的第 n-1 位遍历到第0位，如果使用 for 循环，range 的起始位置应该是 n -1, 终止位置应该是 -1 (不包括 -1，只遍历到 0)， 步长应该为 -1

# 倒序遍历
for i in range(n - 1, -1, -1):

for 循环从 n - 1 开始，逐渐减小 i 的值，直到 0，这样就实现了从最后一个元素向第一个元素遍历的效果。

在循环中，使用 nums[i] 访问列表 nums 中的元素，并使用 print 函数将元素输出到标准输出，不过每位元素的输出之后应该有一个空格。

# 输出列表元素，并添加空格
print(nums[i], end=" ")

这里的end=" " 参数指定在每个输出之后添加一个空格，以便在输出元素之间添加空格分隔符。

完整的代码如下：

n = int(input())  # 输入数组长度

nums = list(map(int, input().split()))  # 输入数组元素，将其分割并转换为整数列表

# 倒序输出元素，每个数之间用空格分隔
for i in range(n - 1, -1, -1):
    print(nums[i], end=" ")

四、隔位输出

题目的第二个要求是每隔一个元素输出其值，中间用空格分隔，只需要对列表从索引为0的位置进行遍历，每次递增2，中间输出空格，这样就能保证输出索引为0、2、4、……位置的元素，代码如下：

# 遍历顺序从0 到 n(不包括n), 步长为 2
for i in range(0, n, 2):
      # 输出元素和空格
    print(nums[i], end=" ")

不过不要忘记在倒序输出和隔位输出之间有一个换行，每次调用 print() 都会在输出内容后自动添加一个换行符，从而将下一个输出移到新的一行。完整的代码如下：

n = int(input())  # 输入数组长度

nums = list(map(int, input().split()))  # 输入数组元素，将其分割并转换为整数列表

# 倒序输出元素，每个数之间用空格分隔
for i in range(n - 1, -1, -1):
    print(nums[i], end=" ")
    
# 换行输出
print()

# 隔位输出元素，每个数之间用空格分隔
for i in range(0, n, 2):
    print(nums[i], end=" ")

五、扩展

1.序列

在Python中，序列是一种数据结构，它存储一组有序的元素。每个元素都分配一个数字——它的位置或索引，第一个索引是0，第二个索引是1，依此类推。Python内置了几种序列类型，包括列表、元组和字符串。

1.列表（List）：列表是可变的序列，允许添加、删除或更改其中的元素。列表是最常用的Python数据类型之一，适合用于需要经常修改其元素的情况。

my_list = [1, 2, 3, "hello", True]
my_list.append(4)  # 添加元素
print(my_list)  # 输出: [1, 2, 3, 'hello', True, 4]

2.元组（Tuple）：元组是不可变的序列，一旦创建就不能修改。它通常用于保护数据不被修改，或者用作字典的键（因为只有不可变类型才能作为字典的键）。

my_tuple = (1, 2, 3, "hello", True)
print(my_tuple[1])  # 输出: 2

3.字符串实际上是一个字符序列，它也是不可变的。这意味着一旦创建了一个字符串，就不能修改它的任何部分。

my_string = "Hello, World!"
print(my_string[7])  # 输出: W

序列有一些共同的特性，比如可以通过索引访问、切片、长度计算、迭代等，也就是说切片和for循环操作在元组和字符串中也可以进行。

# 列表
my_list = [1, 2, 3]
# 元组
my_tuple = (1, 2, 3)
# 字符串
my_string = "hello"

# 索引访问
print(my_list[0])
print(my_tuple[0])
print(my_string[0])

# 遍历
for item in my_list:
    print(item)

for item in my_tuple:
    print(item)

for character in my_string:
    print(character)

2.可变值与不可变值

在Python中，数据类型可以分为两种，主要用于描述数据在创建后是否可以被改变。

可变：创建后，可以在原地进行修改、包括列表、字典、集合等(后面会介绍字典和集合这两种数据类型)。
不可变： 一旦创建，就不能被修改，包括整数、浮点数、字符串、元组等

所以可变，不可变是指当改变值的时候，是否会创建一个新的对象。用下面这个例子来解释：

假设现在有一个变量words = “hello”, 将变量words和字符串hello之间做了关联，现在想要将words的值修改会hello,world, 它并不会在原来hello上面添加内容更改为"hello,world", 而是创建一个新的值，再把这个新值和words变量相关联。

而假设一个变量my_list = [1,2,3], 将变量my_list和列表[1,2,3] 之间做了关联，现在想要将my_list的值修改会[1,2,3,4],它会直接在原来的列表上添加值，并没有创建一个新的值，还是和原来的列表进行关联。