跟着我学Python基础篇：06.列表

往期文章

跟着我学Python基础篇：01.初露端倪
跟着我学Python基础篇：02.数字与字符串编程
跟着我学Python基础篇：03.选择结构
跟着我学Python基础篇：04.循环
跟着我学Python基础篇：05.函数

---

1. 列表的基本属性

列表是一个存储按线性或顺序组织的元素集合的容器。列表在增加元素时可以自动增长为任意需要的大小。

1.1 创建列表

values=[32,54,67,5,29,35,80,115,44.5,100,65]

方括号我们表示正在创建列表，元素是按照给出顺序存储的。

1.2 访问元素列表

列表是一系列元素，每个元素都有一个整数位置或者索引，为了访问列表中的一个元素，你需要指定想使用哪个索引，这个任务使用下标运算符“[]”，如同访问字符串中单个字符一样。

values=[32,54,67,5,29,35,80,115,44.5,100,65]
print(values[5])

列表和字符串有两个不同之处，列表可以包含任意值，而字符串是字符序列，另外字符串是不可变的，你不能修改字符串中的字符，但是列表是可便的，可以把列表中的元素替换为另一个。

注意，列表中的索引是从0开始的。

1.3 遍历列表

有两种可以访问列表中的所有元素，你可以对所有索引值进行循环并查询每个元素，或者可以对所有元素进行循环。

values=[32,54,67,5,29,35,80,115,44.5,100,65]
for i in range(11):
    print(values[i],end=" ")
print()
for element in values:
    print(element,end=" ")

1.4 列表引用

当把一个列表变量复制给另一个变量时，两个变量引用同一个列表。第二个变量是第一个变量的别名。

values=[32,54,67,5,29,35,80,115,44.5,100,65]
for i in range(11):
    print(values[i],end=" ")
print()
scores=values
for element in scores:
    print(element,end=" ")

1.5 反向下标

和很多语言不同，Python还允许在访问列表元素时使用负数下标，负数下标提供了按相反顺序访问列表元素的方法，例如，下标-1可以访问列表中的最后一个元素。

2. 列表操作

2.1 追加元素

有些时候，我们创建了一个列表，但是我们并不知道该用列表来做些什么，在这种情况下，我们可以创建空列表，然后根据需要来追加元素。

#创建一个空列表
friends=[]
#追加元素
friends.append("Tom")
friends.append("Jerry")

for element in friends:
    print(element)

2.2 插入元素

有些时候我们并不能无脑添加，而是需要插入到列表的指定位置。

friends=["Tom","Jerry","Tutu"]
#在Jerry后面插入Xiaomei
friends.insert(2,"Xiaomei")
for element in friends:
    print(element)

2.3 查找元素

如果你想知道一个元素是否存在一个列表中，使用in运算符：

friends=["Tom","Jerry","Tutu"]
friends.insert(2,"Xiaomei")
if "Tutu" in friends:
    print("yes")

列表中index方法会返回元素第一次出现的索引：

friends=["Tom","Jerry","Tutu"]
friends.insert(2,"Xiaomei")
n=friends.index("Xiaomei")
print(n)

如果这个值在列表中出现多次，你可以调用index方法并指定要查找的起始位置。下面的代码从上一次匹配的位置后面查找。

friends=["Tom","Jerry","Tutu","Xiaomei"]
friends.insert(2,"Xiaomei")
n1=friends.index("Xiaomei")
n2=friends.index("Xiaomei",n1+1)
print(n2)

使用index方法时，要查找的元素必须在列表中，否则会引发运行时的异常，所以，在使用index之前使用in方法来判断一下是一个不错的选择。

2.4 删除元素

列表的pop方法删除指定位置上的元素，假如我们有一个列表：

friends=["Tom","Jerry","Tutu","Xiaomei"]

我们要删除位置为1的jerry元素：

friends=["Tom","Jerry","Tutu","Xiaomei"]
for element in friends:
    print(element,end=" ")
friends.pop(1)
print()
for element in friends:
    print(element,end=" ")

被删除的元素后面所有元素向上移动一个位置来填充这个空隙，列表的大小减一。
列表中被删除元素将被pop返回，如果你调用pop方法时没有参数，它会删除并返回列表中的最后一个元素。
列表使用remove方法按值删除一个元素，不是按位置。

friends=["Tom","Jerry","Tutu","Xiaomei"]
for element in friends:
    print(element,end=" ")
friends.remove("Xiaomei")
print()
for element in friends:
    print(element,end=" ")

被删除的元素必须在列表中，否则会引发异常，为了避免运行时的错误，应该在试图删除一个元素之前首先确认一下元素在列表中：

element="Xiaomei"
if element in friends:
    friends.remove(element)

2.5 连接与重复

两个列表连接之后得到一个新列表，其中首先包含第一个列表的元素，然后是第二个列表的元素。
两个列表可以使用“+”运算符连接到一起：

A=[1,3,5,7,9]
B=[0,2,4,6,8]
C=A+B
for element in C:
    print(element,end=" ")

我们想重复一个列表多次，可以用“*”来表示重复的次数：

A=[1,3,5,7,9]
B=[0,2,4,6,8]
C=A*4
for element in C:
    print(element,end=" ")

2.6 相等性测试

“==”运算符比较两个列表是否以同样的顺序包含同样的元素。与之相反的运算符是“！=”

A=[1,3,5,7,9]
B=[1,3,5,7,9]
C=[9,1,3,5,7]
if A==B:
    print("yes")
else:
    print("no")
if(A==C):
    print("yes")
else:
    print("no")
if A!=B:
    print("no")
else:
    print("yes")
if(A!=C):
    print("no")
else:
    print("yes")

2.7 求和，最大值，最小值和排序

求和：sum
最大值：max
最小值：min
排序：sort

a=sum(A)
b=max(A)
c=min(A)
C.sort()
print(a)
print(b)
print(c)
for element in C:
    print(element,end=" ")

2.8 复制列表

列表本身不包含列表元素的值，而是包含一个指向真实列表的引用。如果复制这个引用，你会得到相同列表的另一个引用。

有时候你需要对一个列表进行复制，也就是得到一个与原列表以同样顺序包含同样元素的新列表，使用list函数：

A=[1,3,5,7,9]

D=list(A)
for element in D:
    print(element,end=" ")

2.8 切片

在Python中，切片运算符用于对序列（如字符串、列表、元组等）进行切片操作，提取出所需的子序列。切片运算符使用冒号（:）表示，并可以指定起始位置、结束位置和步长。

切片运算符的基本语法如下：

sequence[start:end:step]

其中，sequence表示待切片的序列，start表示起始位置（包含），end表示结束位置（不包含），step表示步长（可选，默认为1）。

下面是一些常见的切片操作示例：

1. 提取子序列：可以通过指定起始位置和结束位置来提取子序列。

s = "Hello, world!"
print(s[7:12])  # 输出 "world"

2. 指定步长：可以通过指定步长来间隔提取元素。

numbers = [0, 1, 2, 3, 4, 5, 6, 7, 8, 9]
print(numbers[1:9:2])  # 输出 [1, 3, 5, 7]

3. 省略参数：省略起始位置表示从序列的开头开始，省略结束位置表示直到序列的末尾，省略步长表示默认为1。

s = "Hello, world!"
print(s[:5])  # 输出 "Hello"
print(s[7:])  # 输出 "world!"
print(s[::2])  # 输出 "Hlo ol!"

4. 使用负数索引：可以使用负数索引来从序列的末尾开始计数。

numbers = [0, 1, 2, 3, 4, 5, 6, 7, 8, 9]
print(numbers[-4:-1])  # 输出 [6, 7, 8]

需要注意的是，切片操作返回的是一个新的序列，原始序列不会被修改。此外，切片操作是可选的，如果不提供任何参数，则将返回原始序列的副本。

切片运算符在Python中非常有用，它简便地实现了对序列的灵活操作，使得我们可以轻松地获取所需的子序列。

2.8 元组

在Python中，元组（Tuple）是一种不可变的有序序列。它类似于列表（List），但与列表不同的是，元组的元素不能被修改。元组使用圆括号 () 表示，其中的元素可以是任意类型，并且可以包含重复的元素。

以下是一些关于元组的基本操作示例：

1. 创建元组：

# 使用圆括号创建元组
my_tuple = (1, 2, 3)
print(my_tuple)  # 输出 (1, 2, 3)

# 可以省略圆括号
my_tuple = 1, 2, 3
print(my_tuple)  # 输出 (1, 2, 3)

# 使用内置函数 tuple() 创建元组
my_tuple = tuple([1, 2, 3])
print(my_tuple)  # 输出 (1, 2, 3)

2. 访问元组元素：

my_tuple = (1, 2, 3)
print(my_tuple[0])  # 输出 1
print(my_tuple[1:])  # 输出 (2, 3)

3. 元组解包：

my_tuple = (1, 2, 3)
a, b, c = my_tuple
print(a)  # 输出 1
print(b)  # 输出 2
print(c)  # 输出 3

4. 元组拼接：

tuple1 = (1, 2, 3)
tuple2 = (4, 5, 6)
concatenated_tuple = tuple1 + tuple2
print(concatenated_tuple)  # 输出 (1, 2, 3, 4, 5, 6)

5. 元组遍历：

my_tuple = (1, 2, 3)
for item in my_tuple:
    print(item)

元组的不可变性使得它在一些特定场景下很有用，例如用于表示一组常量值或作为字典的键。同时，元组还可以作为函数的返回值，方便地返回多个值。
需要注意的是，由于元组的不可变性，如果需要对元组进行修改或添加元素，只能创建一个新的元组。