Python 列表、元组

1. 列表

1.1 列表介绍

1.2 列表的循环遍历

1.3 列表的常用操作

2. 元组

2.1 元组介绍

2.2 元组的常用操作

2.3 多维列表/元组的访问

 

1. 列表

1.1 列表介绍

Python的列表比C语言的数组强大的地方在于，列表中的元素可以是不同类型的。

li = [1, "a", 1.2, [1, 2], (1, 2), {1:2}, {1, 2}]

  

1.2 列表的循环遍历

使用for循环

>>> li = [1, "a", 1.2, [1, 2], (1, 2), {1:2}, {1, 2}]
>>> li
[1, 'a', 1.2, [1, 2], (1, 2), {1: 2}, {1, 2}]
>>> for i in li:
...     print(i)
...
1
a
1.2
[1, 2]
(1, 2)
{1: 2}
{1, 2}

使用While循环

>>> li = [1, "a", 1.2, [1, 2], (1, 2), {1:2}, {1, 2}]
>>> num = len(li)
>>> flag = 0
>>> while flag < num:
...     print(li[flag])
...     flag+=1
...
1
a
1.2
[1, 2]
(1, 2)
{1: 2}
{1, 2}

 带索引的遍历

>>> # 方法一
>>> li = ["one", "two", "three"]
>>> num = 1
>>> for i in li:
...     print("%d：%s" % (num, i))
...     num += 1
...
1：one
2：two
3：three
>>> 
>>> # 方法二：使用enumerate()函数
>>> for num, i in enumerate(li):
...     print("%d：%s" % (num, i))
...
0：one
1：two
2：three

 

1.3 列表的常用操作

创建

>>> # 方法一
>>> li = [1, 2, "a"]
>>> 
>>> # 方法二：使用list()函数
>>> li = list()  # 创建空列表
>>> li
[]
>>> list((1, "a"))  # 传入元组
[1, 'a']
>>> list([1, 2])  # 传入列表
[1, 2]
>>> list("abcd")  # 传入字符串
['a', 'b', 'c', 'd']
>>> list({1:2, "a":3})  # 传入字典，仅返回键
[1, 'a']
>>> list({1, 2, 3})  # 传入集合
[1, 2, 3]

 增

• append()：向列表中添加元素。
• extend()：将另一个列表中的元素添加至列表中。
• insert(index, obj)：在列表中的指定索引位置index插入元素obj。

示例：

>>> li = ["a", 1]
>>> li.append(2)
>>> li
['a', 1, 2]
>>> li.extend([3,4,5])
>>> li
['a', 1, 2, 3, 4, 5]
>>> li.insert(1,"b")
>>> li
['a', 'b', 1, 2, 3, 4, 5]

删

• del：根据索引删除元素。
• pop()：删除最后一个元素，并会返回该元素。
• remove()：根据元素的值进行删除（若元素重复存在，则只删除第一个）。

>>> li
['a', 'b', 1, 2, 3, 4, 5]
>>> del li[0]
>>> li
['b', 1, 2, 3, 4, 5]
>>> li.pop()
5
>>> li
['b', 1, 2, 3, 4]
>>> li.remove(1)
>>> li
['b', 2, 3, 4]

改

通过索引来修改指定元素。

>>> li
['b', 2, 3]
>>> li[0] = "c"
>>> li
['c', 2, 3]

查

• in、not in（Python中常用的查找方法）
  • in：如果存在则返回True，反之返回False。
  • not in：如果不存在则返回True，反之返回False。
• index()：list.index(obj, start, end) 与字符串中的用法一样，检查元素obj在索引（start和end）之间是否包含在列表list中，如果是，则返回str开始的索引；若不包含则返回一个异常。
• count()：list.count(obj, start, end) 与字符串中的用法一样，返回元素obj在索引（start和end）之间在列表list中出现的次数。

>>> li
['c', 2, 3]
>>> 2 in li
True
>>> 2 not in li
False
>>> li.index(3)
2
>>> li.append(2)
>>> li.count(2)
2
>>> li.count("c")
1
>>> # 查找最后一个2的索引值
>>> li = [1, 2, 5, 2, 4, 6]
>>> len(li) - 1 - (li[::-1].index(2))
>>> 3

排序

• sort(key, reverse)：将list按特定顺序排序（默认是从小到大），参数reverse设为True可改为倒序（即从大到小）。
• reverse()：将list的元素按逆序排序。

>>> li = [2, 3, 1, 5]
>>> li.reverse()
>>> li
[5, 1, 3, 2]
>>> li.sort()
>>> li
[1, 2, 3, 5]
>>> li.sort(reverse=True)
>>> li
[5, 3, 2, 1]

自定义排序：sort()函数的参数key的作用

• 参数key是一个函数，这个函数的作用是从list中的每个元素中提取用于作为排序依据的属性。也就是说key是一个函数，输入是list的每一个元素，输出是用于排序的东西，默认的排序依据是list的单个元素。
• 举例：list = [(3, 66), (5, 3), (1, 23)]，该list的元素是元组，默认来说，list.sort()后，list = [(1, 23), (3, 66), (5, 3)]。如果排序依据是每个元组的第二个元素，可以使用以下方法：

>>> list = [(3, 66), (5, 3), (1, 23)]
>>> # 方法一：编写函数
>>> def f(item):
...     return item[1]
...
>>> list.sort(key=f)
>>> list
[(5, 3), (1, 23), (3, 66)]


>>> list = [(3, 66), (5, 3), (1, 23)]
>>> # 方法二：使用匿名函数
>>> list.sort(key=lambda item:item[1])
>>> list
[(5, 3), (1, 23), (3, 66)]

练习题：对一个 list 中的元素进行去重

方式1：使用 set() 函数直接去重

 # 需要去重的列表
 raw_list = [1, 2, 2, "a", "a", 5, [12], [12]]
 
 # 该方法的缺陷：原列表中不可存在可变类型，否则会报错
 # print(set(raw_list))

方式2：借用临时列表

# 存放去重后的新列表
new_list = []
 
for i in raw_list:
# 遍历旧列表，如果该元素已存在新列表中，则不添加
if i not in new_list:
        new_list.append(i)
        
print(new_list)  # [1, 2, 'a', 5, [12]]

方式3：利用字典 key 不能重复的特点

# 需要去重的列表
raw_list = [1, 2, 2, "a", "a", 5]

# 此方法缺陷：原列表中不可存在可变类型，否则会报错
result = list(dict.fromkeys(raw_list, 0))
print(result)  # [1, 2, 'a', 5]

方式4：count() + remove()

# 需要去重的列表
raw_list = [1, 2, 2, "a", "a", 5, [12], [12]]

for i in raw_list:
    if raw_list.count(i) > 1:
        for j in range(raw_list.count(i)-1):
            raw_list.remove(i)

print(raw_list)  # [1, 2, 'a', 5, [12]]

方法5：从后往前遍历，判断该元素是否存在于当前位置之前的子列表中

# 需要去重的列表
raw_list = [1, 2, 2, "a", "a", 5, [12], [12]]

for i in range(len(raw_list)-1, 0, -1):
    if raw_list[i] in raw_list[:i]:
        raw_list.pop(i)

print(raw_list)

 

 

2. 元组

2.1 元组介绍

Python中的元组与list相似，不同之处在于：

• 元组的元素不能修改。
• 元组使用小括号，列表使用中括号。

t = (1, "a", 1.2, [1, 2], (1, 2), {1: 2}, {1, 2})

注意：元组元素不可变指的是元素的内存地址不可变，若元素为可变类型，则可变类型中的元素是可变的。

>>> a=(1,2,3,[4,5,6],{1:2})
>>> a[4]["x"]="abc"
>>> a
(1, 2, 3, [4, 5, 6], {1: 2, 'x': 'abc'})

  

2.2 元组的常用操作

创建

>>> # 方法一
>>> t = (1, "a", 1.2, [1, 2], (1, 2), {1: 2}, {1, 2})
>>> t
(1, 'a', 1.2, [1, 2], (1, 2), {1: 2}, {1, 2})
>>> 
>>> # 方法二：使用tuple()函数
>>> tuple()
()
>>> tuple((1, 2, 3))
(1, 2, 3)
>>> tuple([1, 2, "c"])
(1, 2, 'c')
>>> tuple("abcd")
('a', 'b', 'c', 'd')
>>> tuple({1: 2, 2: "a"})
(1, 2)
>>> tuple({"a", 1})
(1, 'a')

查

• in、not in（Python中常用的查找方法）
  • in：如果存在则返回True，反之返回False。
  • not in：如果不存在则返回True，反之返回False。
• index()：tuple.index(obj, start, end) 与字符串中的用法一样，检查元素obj在索引（start和end）之间是否包含在元组tuple中，如果是，则返回str开始的索引；若不包含则返回一个异常。
• count()：tuple.count(obj, start, end) 与字符串中的用法一样，返回元素obj在索引（start和end）之间在元组tuple中出现的次数。

>>> # 访问元组的元素
>>> t = (1, 2, 3, 1, 2, 5)
>>> t[2:4]
(3, 1)
>>> t[::-1]
(5, 2, 1, 3, 2, 1)
>>> # 使用函数
>>> 5 in t
True
>>> 4 not in t
True
>>> t.index(2)
1
>>> t.count(2)
2

 

 2.3 多维列表/元组的访问

>>> li = [(1, 2),[3, 4]]
>>> li[0][0]
1
>>> li[1][0]
3
>>> t = (("a", "b"), ["c", "d"])
>>> t[1][1]
'd'
>>> t[0][1]
'b'