Python基础系列-列表(list)

列表

Python中的列表类似于JS中的数组，其是按照 顺序 存储数据的，数据类型可以为任意类型，如：数字、字符串、布尔、列表、元组、字典等。

在Python中，list是一个类

help(list) # 可以查看list的类型、构造函数、方法及具体用法dir(list) # 可以查看list的所有方法

创建列表

创建列表的方式包括两种：字面量方式及构造函数方式，与JS中创建数组的方法类似。

1. 字面量

变量名 = [elem1, elem2, …]

elem1, elem2, … 可以为任意数据类型

nums = [1, 2, 3, 4] # // 使用字面量创建一个列表type(nums) # -> <class 'list'>

2. 构造函数

• 创建一个空列表

  变量名 = list()

• 基于可迭代对象，创建一个列表

  变量名 = list(iterable)

# 无参数，创建一个空列表lst = list() # -> []# 字符串lst = list('hello') # -> ['h', 'e', 'l', 'l', 'o']# 列表lst = list([1, 2, 3]) # -> [1, 2, 3]# 元组lst = list((1, 2, 3)) # -> [1, 2, 3]# 集合lst = list({1, 2, 3}) # -> [1, 2, 3]# 字典, 只获取keyslst = list({'name': 'py', 'age': 18}) # -> ['name', 'age']

访问列表

1. 索引方式（[index]）

• 返回值为指定索引位置的元素
• 从 0 开始，0表示第一个元素的索引
• 支持 负数 ，-1表示倒数第一个元素，以此类推
• 索引是不安全操作，超出列表范围，会触发IndexError错误

nums = [1, 2, 3, 4]# 索引操作first_num = nums[0] # 第一个元素last_num = nums[-1] # 最后一个元素 <=> nums[len(nums)-1]error_num = nums[100] # -> IndexError

2. 切片方式（[start:end]）

• 返回值为一个新 列表
• 方向是 从左到右
• 范围为包含start，但不包含end，即：前闭后开
• 支持 负数 ，-1表示倒数第一个元素的索引，以此类推
• 可以省略，start省略，默认为0，end省略，默认为列表的长度
• 切片是安全操作，不会触发错误，超出部分会被忽略
• 如果指定的切片范围没有要素，则返回一个空列表

nums = [1, 2, 3, 4]# 切片操作nums[0:2] # -> [1, 2]，前闭后开nums[:] # -> [1, 2, 3, 4]，start及end都省略nums[1:] # -> [2, 3, 4]，end省略nums[:2] # -> [1, 2]，start省略nums[-3:-1] # -> [2, 3]，支持负数nums[-100:100] # -> [1, 2, 3, 4]，范围大于列表自身范围nums[-1:-3] # -> []，范围内没有元素

修改列表

使用索引方式，修改列表指定索引位置的元素

索引不能超出列表范围，否则报错IndexError

nums = [1, 2, 3, 4]nums[0] = 0print(nums) # -> [0, 2, 3, 4]nums[10] = 10 # -> IndexError# 与JS不同，超出范围，JS会自动添加元素，数组长度与指定索引之间的元素为undefined

遍历列表

1. for循环

for循环是迭代循环，是最常用的循环语句，但不能在for循环中，对列表进行添加和删除操作。

nums = [1, 2, 3, 4]for val in nums:    print(val)

2. while循环

while循环式条件循环，可以在循环中，对列表进行各种操作。

nums = [1, 2, 3, 4]cur_index = 0 # 当前索引nums_len = len(nums) # 列表的长度while cur_index >= nums_len:    cur_num = nums[cur_index]    print(cur_num)    cur_index += 1 # 编写代码时，常被忽略，造成无限循环

删除列表

使用del操作符。

nums = [1, 2, 3]del nums # 删除列表

常用操作

1. 增加

• append(object)

  作用：向列表末尾添加元素

  参数：任意类型数据

  返回值：None

  原有列表改变

  是安全操作

nums = [1, 2, 3]nums.append(4) # -> Noneprint(nums) # -> [1, 2, 3, 4]

• insert(index, object)

  作用：向指定索引位置，插入元素

  参数：index为索引位置，object为待插入元素

  返回值：None

  原有列表改变

  是安全操作，如果index位置超出范围，则默认设置为范围的开头或者末尾

nums = [1, 2, 3]nums.insert(0, 0) # -> Noneprint(nums) # -> [0, 1, 2, 3]# index超出范围，默认为0nums.insert(-10, -1) # -> Noneprint(nums) # -> [-1, 0, 1, 2, 3]# index超出范围，默认为5nums.insert(10, 4) # -> Noneprint(nums) # -> [-1, 0, 2, 3, 4]

• extend(iterable)

  作用：将可迭代对象中的元素，按照顺序添加到列表中

  参数：可迭代对象

  返回值：None

  原列表改变

  安全操作

nums = [1, 2]lst = [3, 4, 5]# extend操作nums.extend(lst) # -> Noneprint(nums) # -> [1, 2, 3, 4, 5]# 与append的区别# append(object)方法是将object作为一个元素，添加到列表中# extend(iterable)方法是将iterable中的元素，按照顺序一个一个地添加到列表中nums = [1, 2]nums.append(lst) # -> Noneprint(nums) # -> [1, 2, [3, 4, 5]]

2. 删除

• pop([index])

  作用：删除指定索引(index)位置的元素，并返回该元素

  参数：index可选，默认为最后一个元素的索引

  返回值：被删除的元素

  原列表改变

  不安全操作，如果index超出列表范围，则报错IndexError

nums = [1, 2, 3, 4, 5, 6]# index默认值为最后一项的索引nums.pop() # -> 6# 指定indexnums.pop(0) # -> 1nums.pop(-1) # -> 5# index超出列表范围nums.pop(10) # -> IndexError

• remove(value)

  作用：删除列表中第一次出现value的元素

  参数：元素值

  返回值：None

  原列表改变

  不安全操作，如果value不在列表中，则报错ValueError

nums = [1, 2, 1, 3, 4, 2]# 删除nums.remove(1) # -> Noneprint(nums) # -> [2, 1, 3, 4, 2]# value不在列表中nums.remove(10) # -> ValueError

• clear()

  作用：清空列表

  参数：无

  返回值：None

  原列表改变

  安全操作

nums = [1, 2]# 清空列表nums.clear() # -> Noneprint(nums) # -> []

• del 语句

  作用：删除指定元素、变量等

  无参数

  无返回值

  原列表改变

  操作不安全，如果索引超出列表范围，则报错IndexError

nums = [1, 2, 3]# del删除del nums[0] # 删除第一项print(nums) # -> [2, 3]del nums[10]; # -> IndexError

3. 修改

对列表中的元素进行修改，即：更新列表中元素的值，常用的方式为索引方式，参见修改列表部分。

4. 查找

列表中常用的查找方式包括以下三种：

• 根据索引获取元素

  参见访问列表部分

• 根据值获取索引

  index(value, [start, [stop]])

  作用：在指定的范围内，查找value第一次出现的索引位置，并返回

  参数：

  • value：必选参数，元素值

  • start：可选参数，开始查找的索引位置，默认值为0

  • stop：可选参数，结束查找的索引位置，但不包括该位置，默认值为列表长度

  start参数省略时，stop参数也必须省略

  stop参数不能省略时，start参数也不能省略

  返回值：integer，索引位置

  原列表不变

  不安全操作，如果value不在列表中，则报错ValueError

  nums = [1, 2, 3, 4, 3, 4, 6]# 省略start及stopnums.index(3) # -> 2# 省略stopnums.index(3, 3) # -> 4# 都不省略nums.index(3, 3, 4) # -> ValueError: 3 is not in list# 使用*args参数nums.index(3, *[3, 5]) # -> 4，等同于nums.index(3, 3, 5)

• 获取元素出现的次数

  count(value)

  作用：查找并返回value在列表中出现的次数

  参数：元素值

  返回值：integer，value出现的次数

  原列表不变

  安全操作，如果value不在列表中，则返回0

  nums = [1, 2, 3, 4, 3, 4, 6]nums.count(3) # -> 2nums.count(5) # -> 0，5不在nums列表中

5. 复制

• copy()

  作用：对列表进行浅复制，并返回

  参数：无

  返回值：list，当前列表的一份浅复制

  原列表不变

  安全操作，不会触发错误

  nums = [1, 2, [3, 4]]# copynums_copy = nums.copy() #- > [1, 2, [3, 4]]# 理解什么是浅复制nums[0] = 0 # 原列表修改print(nums) # -> [0, 2, [3, 4]]print(nums_copy) # -> [1, 2, [3, 4]]，复制列表未变nums[2].append(5) # -> 修改原列表中第三项元素的值print(nums) # -> [0, 2, [3, 4, 5]]print(nums_copy) # -> [1, 2, [3, 4, 5]]，复制列表也改变了

• 切片

  切片的详细用法参见访问列表部分，完全浅复制一份列表，使用[:]。

  nums = [1, [2, 3]]# 复制nums_copy = nums[:]print(nums_copy) # -> [1, [2, 3]]# 使用切片复制产生的新列表也是浅复制nums[0] = 0print(nums) # -> [0, [2, 3]]print(nums_copy) # -> [1, [2, 3]], 不变nums[1].append(4) # 修改原列表print(nums) # -> [0, [2, 3, 4]]print(nums_copy) # -> [1, [2, 3, 4]], 复制列表也发生改变

6. 排序

• reverse()

  作用：将列表进行反转

  参数：无

  返回值：无

  原列表改变

  安全操作，不会触发错误

  nums = [1, 2, 3]nums.reverse() # 反转列表print(nums) # -> [3, 2, 1]

• sort(key=None, reverse=False)

  作用：对列表进行排序，默认为升序排序

  参数：

  • key：默认参数，默认值为None，如果指定该参数，则使用该参数对元素进行处理后再进行比较
  • reverse：默认参数，默认值为False，不对排序结果进行反转，如果为True，则对排序结果进行反转

  返回值：None

  原列表改变

  不安全操作，如果列表中的元素不能比较，则触发TypeError错误

  # 元素之间不能比较lst = ['2', '1', 3]lst.sort() # -> TypeError: '<' not supported between instances of 'str' and 'int'# 元素之间可以进行比较nums = [3, 2, 6, 5, 4]nums.sort() # -> Noneprint(nums) # -> [2, 3, 4, 5, 6]，原列表改变# 指定reverse为Truenums.sort(reverse=True) # -> Noneprint(nums) # -> [6, 5, 4, 3, 2]，排序之后再反转# 指定Keylst.sort(key=str) # -> None，使用str()函数，对元素进行处理，转换为字符串之后，再进行比较print(lst) # -> ['1', '2', 3]

运算

1. 运算符

• +

  支持两个列表相加，返回一个组合后的新列表

  lst_1 = [1, 2]lst_2 = [3, 4]lst_res = lst_1 + lst_2 # -> [1, 2, 3, 4]# 浅复制lst = [1, [2, 3]]lst_cp = lst + [] #- > 与一个空列表相加print(lst_cp) # -> [1, [2, 3]]lst[1].append(4) # 改变原列表print(lst) # -> [1, [2, 3, 4]]，原列表发生了改变print(lst_cp) # -> [1, [2, 3, 4]]，复制后的列表也发生了改变

• *

  支持一个列表与一个整数相乘，返回一个复制指定次数的新列表

  如果整数位负数，则返回空列表

  如果整数位正数，则将列表复制整数份，然后组合成一个新列表

  lst_1 = [1, 2]lst = lst_1 * (-2) # -> []lst = lst_1 * 2 # -> [1, 2, 1, 2]

2. 内置函数(BIF)

• len(obj, /)

  作用：获取obj中元素的个数

  参数：对象

  返回值：个数

  原对象不改变

  len([1, 2, 3]) # -> 3

• min(…)

  获取iterable或者一系列元素中的最小值，iterable中的所有元素之间都支持比较操作，如果不支持，报错TypeError

  lst = [1, 2, 3, 2, 5, 4, 0]min(lst) # -> 0lst = [1, 'a', 2]min(lst) # -> TypeError，'str'与'int'类型之间不能比较

• max(…)

  与min用法相同，但其获取最大值

  lst = [1, 2, 3, 2, 5, 4, 0]max(lst) # -> 5lst = [1, 'a', 2]max(lst) # -> TypeError，'str'与'int'类型之间不能比较

• sum(iterable, start=0, /)

  求iterable中所有元素的和，然后再加上start的值

  只支持数字类型

  lst = [1, 2, 3.1, 4.2]sum(lst) # -> 10.3sum(lst, 10) # -> 20.3lst = ['abc']sum(lst) # -> TypeError

3. 内置操作语句

• del

  删除操作，参见删除列表部分

• in

  判断元素是否存在iterable中，存在返回True，不存在返回False

  not int 用于判断元素是否不存在iterable中，不存在返回True，存在返回False，与in相反

  lst = (1, 'a', True)# inis_in = 1 in lst # -> Trueis_in = 'b' in lst # -> False# not inis_not_in = 1 not in lst # -> Falseis_not_in = 'b' not in lst # -> True

注意事项

1. 索引

涉及索引操作时，要注意，索引不能超出列表范围，否则会报错IndexError

2. 值

涉及值操作时，要注意，值必须在列表中，否则会报错ValueError，除去count()方法