您的位置：首页 > 编程语言 > Python开发

Python基础系列-列表(list)

2017-12-26 11:06 337 查看

列表

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不在列表中，则返回

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()方法

内容来自用户分享和网络整理，不保证内容的准确性，如有侵权内容，可联系管理员处理

标签： python

相关文章推荐

新的分享

章节导航