python数据类型List分析

1. 创建列表

在 python 中, [] 表示一个列表

a = []  
print(type(a))   #<class 'list'>
  
a = list()  
print(type(a))   #<class 'list'>
  
b = [ 1, 2, 3, 4]  
print(type(b))   #<class 'list'>
  
c = [1, 2, 3, 'hello']  
print(type(c))   #<class 'list'>
  
print(c) # [1, 2, 3, 'hello']

• python 中可以用 [] 或者 list() 来表示一个列表
• 列表中的元素可以是不同类型的
• 可以直接使用 print 来打印列表元素

2. 新增列表元素

2.1 append

使用 append 方法可以在列表末尾新增一个元素

a = []  
a.append(1)  
a.append('234')  
print(a) # [1, '234'] 

2.2 insert

使用 insert 方法可以在指定下标位置新增元素

a = []  
a.append(1)  
a.append('234')  
print(a) # [1, '234']  
  
a.insert(1, 'hello')  
a.insert(10, 'world')  
print(a)  # [1, 'hello', '234', 'world']

• Python 是一种面向对象的语言，因此创建出来的列表本质是一个对象，而这里的 append 和 insert 都是列表的成员方法。
• 调用 insert 方法时，如果指定的索引超过了列表中的最大下标，则将待插入元素插入在列表的末尾。

3. 删除列表元素

3.1 pop

• 使用 pop 方法可以删除列表最末尾的元素
• 使用 pop 方法也可以删除指定下标位置的元素

a = [1 , 2 , 3 ,4]  
a.pop()  
print(a) # [1, 2, 3]  
a.pop(1)  
print(a) # [1, 3]

• python 中 list 的下标从 0 开始,这点和 C/C++一样,和 lua 的不同

3.2 remove

• 使用 remove 方法可以指定删除列表中特定值的元素
• 如果列表中存在多个特定值的元素，则 remove 方法只删除首次出现的元素

a = [1 ,2 , 3 , 2, 4]  
a.remove(3)  
print(a) # [1, 2, 2, 4]  
a.remove(2)  
print(a) # [1, 2, 4]

4. 查找列表元素

4.1 in 和 not in 操作符

• 使用 in 和 in not 操作符能够判定某个元素是否在列表中存在

a = [1 , 2 , 3 ,4]  
print(1 in a)      # True  
print(1 not in a)  # False  
  
print(5 in a)      # False  
print(5 not in a)  # True

4.2 index 方法

• 使用 index 方法也可以判定某个元素是否在列表中存在

a = [1 , 2 , 3 ,4]  
print(a.index(2))   # 1
print(a.index(100)) #报错

• 这里的 index 方法()里面查找的是值,返回的是 index,该值在 list 中的下标

5. 下标访问列表元素

5.1 下标访问

• 通过下标访问操作符 [] 可以获取指定下标位置的元素
• 可以通过下标修改访问到的元素的值

a = [1 ,2 , 3 ,4]  
print(a[1]) # 2  
a[1] = 100  # [1, 100, 3, 4]  
print(a)

• 如果指定下标的值超过了列表中的最大下标，则会抛出异常。

5.2 负索引

a =  [ 1, 2 ,3,4]  
#正索引 0  1  2  3
#负索引 -4 -3 -2 -1  
print(a[-1]) # 4

6. 遍历列表元素

6.1 循环

a = [1 , 2, 3, 4]  
  
for i in a:  
    print(i)  
    i = i + 1 # 1 2 3 4  # 不会修改list中的值  
  
print(a) # [1, 2, 3, 4]  
  
for i in range(len(a)):  
    print(a[i])  
    a[i] = a[i] + 10  # 修改列表中的元素值  
print(a)  # [11, 12, 13, 14]  
  
i = 0  
while i < len(a):  
    print(a[i])  # 11 12 13 14  
    i += 1

7. 子列表提取

语法 : [起始下标 : 结束下标]

• 以 [起始下标 : 结束下标] 的方式可以从列表中提取出，从起始下标开始到结束下标的一组元素。
• 左闭右开的区间

a = [1 , 2, 3, 4]  
print(a[1:2]) #[2]

切片时省略边界

• 提取子列表的过程也叫做切片的过程，以 [起始下标 : 结束下标] 的方式切片时可以省略起始下标或结束下标。
• 如果以 [起始下标 : ] 的方式进行切片，则子列表中的元素包括起始下标的元素及其后续元素。
• 如果以 [ : 结束下标] 的方式进行切片，则子列表中的元素包括结束下标之前的所有元素。
• 如果以 [ : ] 的方式进行切片，则子列表中的元素包括原列表中的所有元素。

a = [1, 2, 3, 4]  
print(a[1:])   # [2, 3, 4]  
print(a[:3])   # [1, 2, 3]  
print(a[:-2])  # [1, 2]  
print(a[:])    # [1, 2, 3, 4]

• 切片时也可以使用负索引。

切片时指定步长

• 以 [起始下标 : 结束下标 : 步长] 的方式切片可以指定步长，即每访问一个元素后下标自增几步

a = [1 ,2 ,3 ,4 ,5 ,6 ,7, 8, 9]  
print(a[1::2])   # [2, 4, 6, 8]  
print(a[1::-1])  # [2, 1]  
print(a[1:-1:1]) # [2, 3, 4, 5, 6, 7, 8]  
print(a[-1:1:-1])# [9, 8, 7, 6, 5, 4, 3]
print(a[1:1000]) # [2, 3, 4, 5, 6, 7, 8, 9] # 越界

• 切片时指定的步长也可以为负数，这时表示从后往前提取元素
• 如果切片时填写的下标超出了有效范围，运行程序后不会抛异常，而是尽可能把符合要求的元素提取出来

8. 拼接列表

8.1 使用 + 拼接列表

• 使用+可以把两个列表拼接在一起
• 使用+拼接后会生成一个新的列表，该操作不会影响两个原有列表。
• 使用+=也可以把一个列表拼接到另一个列表的后面

a = [1 ,2 ,3]  
b = [3 ,4 ,5]  
c = a + b  
print(c) #[1, 2, 3, 3, 4, 5]  
print(a) #[1, 2, 3]  
a += b  
print(a)#[1, 2, 3, 3, 4, 5]

8.2 extend 方法

• 使用 extend 方法，可以把一个列表拼接到另一个列表的后面
• a.extend(b) 是把 b 列表中的元素拼接到 a 列表后面，该操作不会修改 b 列表。

a = [1 ,2 ,3]  
b = [3 ,4 ,5]  
a.extend(b)  
print(a) # [1, 2, 3, 3, 4, 5]  
print(b) # [3, 4, 5]

• 拼接列表推荐使用 extend 方法
• 因为 a += b 等价于 a = a + b，拼接过程中会先构造出拼接后的列表，然后将 a 原来的列表释放，再将这个拼接后的列表赋值给 a
• 而 a.extend(b)是直接把 b 列表中的元素拼接到 a 列表后面，避免了不必要的释放操作