【十二】列表对象方法和元组对象方法

名字不好起的名字都有人用？

已于 2023-02-16 10:19:20 修改

阅读量48

点赞数

分类专栏：从零入门玩转python 文章标签： python 开发语言 pycharm

于 2023-02-16 10:13:31 首次发布

本文链接：https://blog.csdn.net/weixin_46395534/article/details/129055710

版权

从零入门玩转python 专栏收录该内容

38 篇文章 2 订阅

订阅专栏

列表对象方法和元组对象方法

前言

列表（List）

List是可变的，它是序列
在方括号中添加元素，并使用逗号隔开

list0 = []
list1 = ['China', 1997, 2000]
list2 = [1, 2, 3, 4, 5]
list3 = ["a", "b", "c", "d"]
list4 = ['red', 'green', 'blue', 'yellow', 'white', 'black']

修改列表

列表是可变的，所以我们可以通过索引和切片的方式来对列表的元素进行修改

list1 = ["h", "e", "l", "l", "o", " ", "1", "牛", "3"]
# 通过索引把列表下标为4对应的元素改为 "-"
list1[4] = "-"
print(list1) # ['h', 'e', 'l', 'l', '-', ' ', '1', '牛', '3']

# 通过切片把列表的前 4 个元素变成大写的字母
list1[0: 4] = ["H", "E", "L", "L", "O", '不定长修改']
print(list1) # ['H', 'E', 'L', 'L', 'O', '不定长修改', '-', ' ', '1', '牛', '3']


# 插入数据
list2 = [1, 2, 3]
list2[0:0] = ['表头插入数据']
list2[len(list2):] = ['表尾插入数据']
print(list2)  # ['表头插入数据', 1, 2, 3, '表尾插入数据']

list([iterable])

将一个iterable对象转化为列表并返回，如果没有传入参数返回空的列表

print(list()) # []
print(list("China")) # ['C', 'h', 'i', 'n', 'a']
print(list((1, 2, 3))) # [1, 2, 3]
print(list({1: 2, 3: 4})) # [1, 3]
print(list({1, 2, 3, 4})) # [1, 2, 3, 4]

列表对象方法

list.append(x)

在列表的末尾添加一个元素（修改原列表，无返回值），相当于 a[len(a):] = [x]

li = [1, 2]
li.append(1)  # 添加数字
print(li)
li.append("1")  # 添加字符串
print(li)
li.append([1, 2])  # 添加列表
print(li)
# [1, 2, 1]
# [1, 2, 1, '1']
# [1, 2, 1, '1', [1, 2]]
li.append((3, 4))  # 添加元组
print(li)
li.append({"身高": 175})  # 添加字典
print(li)
li.append({5, 6})  # 添加集合
print(li)
# [1, 2, 1, '1', [1, 2], (3, 4)]
# [1, 2, 1, '1', [1, 2], (3, 4), {'身高': 175}]
# [1, 2, 1, '1', [1, 2], (3, 4), {'身高': 175}, {5, 6}]

list.extend(iterable)

使用 iterable 中的所有元素来扩展列表（修改原列表，无返回值），相当于 a[len(a):] = iterable

li = [1, 2]
li.extend("1")  # 添加字符串中的元素
print(li)
li.extend([1, 2])  # 添加列表中的元素
print(li)
li.extend((3, 4))  # 添加元组中的元素
print(li)
# [1, 2, '1']
# [1, 2, '1', 1, 2]
# [1, 2, '1', 1, 2, 3, 4]
li.extend({"身高": 175})  # 添加字典中的 键
print(li)
li.extend({5, 6})  # 添加集合中的元素
print(li)
# [1, 2, '1', 1, 2, 3, 4, '身高']
# [1, 2, '1', 1, 2, 3, 4, '身高', 5, 6]

list.insert(i, x)

i：要插入的元素的索引
x：要插入的元素
在给定的位置插入一个元素（修改原列表，无返回值）

li = [1, 2, 3, 4, True, False]
a = [5, 6, 7]

li.insert(1, a)  # 相当于li[1:1] = [[5, 6, 7]]
print(li)  # [1, [5, 6, 7], 2, 3, 4, True, False]

list.sort([key], reverse=False)

key：指定一个函数, 在排序之前, 列表每个元素先应用这个函数之后再
对原数据进行排序
reverse：默认为 False，代表升序，指定为 True 则降序对原列表进行排序，无返回值

num_list = [1, -2, 5, -3]

# 默认reverse=False升序
num_list.sort()
print(num_list) # [-3, -2, 1, 5]

# 指定reverse=True降序
num_list.sort(reverse=True)
print(num_list) # [5, 1, -2, -3]

# key指定为内置函数abs(x), 列表中的每个元素在排序之前, 先应用这
个函数，然后根据应用之后的大小来对原数据排序
num_list.sort(key=abs) # [1, -2, 5, -3] abs-> [1, 2,5, 3] -> [1, 2, 3, 5]
print(num_list) # [1, -2, -3, 5]

sorted(iterable, [key], reverse=False)

iterable：可迭代对象（字符串，列表，元组，字典，集合等）
key：指定一个函数, 在排序之前, 每个元素都先应用这个函数之后再排序
reverse：默认为 False，代表升序，指定为 True 则降序
对可迭代对象进行排序（不对原数据进行操作），以列表形式返回

sort 和 sorted 的区别： list.sort 是只针对列表的排序，对原数据进行操作，无返回值，是列表的对象方法

sorted 可以对所有可迭代的对象进行排序，不对原数据操作，有返回值，是内置函数

num_tup = (1, -2, 5, -3)
result = sorted(num_tup, reverse=False)
print(result)  # [-3, -2, 1, 5]

result = sorted(num_tup, reverse=True)
print(result)  # [5, 1, -2, -3]

result = sorted(num_tup, key=abs)
print(result)  # [1, -2, -3, 5]

list.reverse()

对列表中的元素反向， 无返回值

li = [1, 3, 5, 2]
li.reverse()
print(li) # [2, 5, 3, 1]

reversed(seq)

对给定序列返回一个反向迭代器

reverse 和 reversed 区别： list.reverse是只针对列表的，对原数据进行操作，无返回值，是列表的对象方法

reversed 是针对序列的，不对原数据操作，返回一个反向迭代器，是内置函数

seqString = 'hello world'
result = reversed(seqString)
print(result)  # 一个反向迭代器 #<reversed object at 0x0000021ED98CEDA0>

print(list(result))  # list转化成列表 # ['d', 'l', 'r', 'o', 'w', ' ', 'o', 'l', 'l', 'e', 'h']

list.count(x)

返回元素x在列表中出现的次数

a = [1, 23, 1, 3, 23, "23"]
print(a.count(23)) # 2

list.index(x[, start[, end]])

x：要找的值
start：查找的起始索引位置，默认为 0
end：查找的结束索引位置（不包括这个索引），默认为 len(list)
返回从列表中第一次找到指定值 x 的位置索引，找不到则抛出 ValueError 异常
注意：返回的索引是相对于整个序列开始计算的，而不是 [start:stop] 的子序列

a = [1, 2, 3, 4, 3, 2, 3]

# 找到第一个3的位置索引是2
print(a.index(3)) # 2
# 在索引[3,5)位置区间, 找到第一个3的位置索引是4
print(a.index(3, 3, 5)) # 4

list.pop([i])

i：要删除元素的索引
删除列表中给定位置的元素（修改原列表）并返回该元素
如果没有给定位置，将会删除并返回列表中的最后一个元素

li = [1, 2.3, 2+3j, "4", True, False]
print(li.pop()) # 未给定参数，则删除最后一个元素并返回
print(li) # 删除元素后的列表

print(li.pop(2)) # 删除索引2对应的元素
print(li) # 删除元素后的列表

list.remove(x)

移除列表中第一个匹配到的值为 x 的元素（修改原列表，无返回值）
如果没有这样的元素，则抛出 ValueError 异常

li = [1, 2, 4, 2, 3, 3]

li.remove(2) # 移除第一个2
li.remove(3) # 移除第一个3
print(li) # [1, 4, 2, 3]

li.remove(5) # 没有5，则抛出 ValueError 异常

list.copy()

返回列表的一个浅拷贝，等价于a[:]

li1 = [1, 2, 4, 2, 3, 3]
li2 = li1.copy()
print(id(li1), id(li2)) # 2383560979528 2383533248840
print(li2) # [1, 2, 4, 2, 3, 3]

list.clear()

移除列表中的所有元素（修改原列表，无返回值），等价于 del a[:]

li = [1, 2, 4, 2, 3, 3]

li.clear()
print(li) # []

前言

元组（Tuple）

Tuple 与 List 类似，它也是序列，但 Tuple 是不可变的
在圆括号中添加元素，并使用逗号隔开（或者不加括号也认为是元组）

# 空元组
tup = ()
print(type(tup))

# 空列表
lis = []
print(type(lis))

# 元组
tup = (1, )
print(tup)
print(type(tup))

# 数字
num = (1)
print(num)
print(type(num))

# 列表
lis = [1, ]
print(lis)
print(type(lis))

# 列表
lis = [1]
print(lis)
print(type(lis))

tup1 = ('China', 1997, 2000)
tup2 = (1, 2, 3, 4, 5)
tup3 = "a", "b", "c", "d" # 不需要括号也可以



# Tuple 是不可变的，但是 Tuple 中的列表是可变的
tup = (1, 2, [3, 4, 5])
# lis = tup[2]
# lis[2] = 6
tup[2][2] = 6
print(tup)

tuple([iterable])

返回一个新的 tuple 对象，其元素来自于 iterable，如果未指定 iterable，则将返回空元组

print(tuple()) # 返回空元组 ()
print(tuple("China")) # ('C', 'h', 'i', 'n', 'a')
print(tuple([1, 2, 3])) # (1, 2, 3)
print(tuple({1: 2, 3: 4})) # (1, 3)
print(tuple({1, 2, 3, 4})) # (1, 2, 3, 4)

元组对象方法

tuple.count(x)

返回元素 x 在元组中出现的次数

a = (1, 23, 1, 3, 23, "23")
print(a.count(23)) # 2

tuple.index(x[, start[, stop]])

x：要找的值
start：查找的起始索引位置，默认为 0
stop：查找的结束索引位置（不包括这个索引），默认为 len(list)
返回从元组中第一次找到指定值 x 的位置索引，找不到则抛出 ValueError 异常
注意：返回的索引是相对于整个序列开始计算的，而不是 [start:stop] 的子序列

a = (1, 2, 3, 4, 3, 2, 3)

# 找到第一个3的位置索引是2
print(a.index(3)) # 2
# 在索引[3,5)位置区间, 找到第一个3的位置索引是4
print(a.index(3, 3, 5)) # 4