列表

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]

# 字典, 只获取keys
lst = 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] = 0
print(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) # -> None
print(nums) # -> [1, 2, 3, 4]
  • insert(index, object)
    作用：向指定索引位置，插入元素
    参数：index为索引位置，object为待插入元素
    返回值：None
    原有列表改变
    是安全操作，如果index位置超出范围，则默认设置为范围的开头或者末尾
nums = [1, 2, 3]
nums.insert(0, 0) # -> None
print(nums) # -> [0, 1, 2, 3]

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

# index超出范围，默认为5
nums.insert(10, 4) # -> None
print(nums) # -> [-1, 0, 2, 3, 4]
  • extend(iterable)
    作用：将可迭代对象中的元素，按照顺序添加到列表中
    参数：可迭代对象
    返回值：None
    原列表改变
    安全操作
nums = [1, 2]
lst = [3, 4, 5]
# extend操作
nums.extend(lst) # -> None
print(nums) # -> [1, 2, 3, 4, 5]

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

2. 删除

  • pop([index])
    作用：删除指定索引(index)位置的元素，并返回该元素
    参数：index可选，默认为最后一个元素的索引
    返回值：被删除的元素
    原列表改变
    不安全操作，如果index超出列表范围，则报错IndexError
nums = [1, 2, 3, 4, 5, 6]
# index默认值为最后一项的索引
nums.pop() # -> 6
# 指定index
nums.pop(0) # -> 1
nums.pop(-1) # -> 5
# index超出列表范围
nums.pop(10) # -> IndexError
  • remove(value)
    作用：删除列表中第一次出现value的元素
    参数：元素值
    返回值：None
    原列表改变
    不安全操作，如果value不在列表中，则报错ValueError
nums = [1, 2, 1, 3, 4, 2]
# 删除
nums.remove(1) # -> None
print(nums) # -> [2, 1, 3, 4, 2]
# value不在列表中
nums.remove(10) # -> ValueError
  • clear()
    作用：清空列表
    参数：无
    返回值：None
    原列表改变
    安全操作
nums = [1, 2]
# 清空列表
nums.clear() # -> None
print(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及stop

nums.index(3) # -> 2

# 省略stop

nums.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) # -> 2 nums.count(5) # -> 0，5不在nums列表中

5. 复制

  • copy()
    作用：对列表进行浅复制，并返回
    参数：无
    返回值：list，当前列表的一份浅复制原列表不变
    安全操作，不会触发错误
nums = [1, 2, [3, 4]]

# copy

nums_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] = 0
print(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() # -> None
print(nums) # -> [2, 3, 4, 5, 6]，原列表改变


# 指定reverse为True

nums.sort(reverse=True) # -> None
print(nums) # -> [6, 5, 4, 3, 2]，排序之后再反转


# 指定Key

lst.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) # -> 0

lst = [1, 'a', 2]
min(lst) # -> TypeError，'str'与'int'类型之间不能比较
  • max(…)
    与min用法相同，但其获取最大值
lst = [1, 2, 3, 2, 5, 4, 0]
max(lst) # -> 5

lst = [1, 'a', 2]
max(lst) # -> TypeError，'str'与'int'类型之间不能比较
  • sum(iterable, start=0, /)
    求iterable中所有元素的和，然后再加上start的值
    只支持数字类型
lst = [1, 2, 3.1, 4.2]
sum(lst) # -> 10.3
sum(lst, 10) # -> 20.3

lst = ['abc']
sum(lst) # -> TypeError

3. 内置操作语句

  • del
    删除操作，参见删除列表部分
  • in
    判断元素是否存在iterable中，存在返回True，不存在返回False
    not int 用于判断元素是否不存在iterable中，不存在返回True，存在返回False，与in相反
lst = (1, 'a', True)

# in

is_in = 1 in lst # -> True
is_in = 'b' in lst # -> False

# not in

is_not_in = 1 not in lst # -> False
is_not_in = 'b' not in lst # -> True

注意事项

1. 索引

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

2. 值

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