Python学习笔记：集合数据类型

集合数据类型

Python 语言中有四种集合数据类型：

• 列表（List）
• 元组（Tuple）
• 集合（Set）
• 字典（Dictionary）

选择集合类型时，了解该类型的属性很有用。他们在总体功能上都起着存放数据的作用，却都有着各自的特点。

列表

列表（list）是一个有序且可更改的集合，可以存放任意数据类型，包括列表本身。使用方括号[ ]来创建一个列表。

list1 = [1, 3.14, "hello", [1, 2, 3]]

与字符串的索引一样，列表索引从0开始。列表可以进行截取、组合等。

列表的转换

可以使用工厂函数把其他数据类型转化为list，要求原数据类型是可迭代对象（即能被for循环遍历的），如list、tuple、dict、set、str。

list1 = list("abc")
print(list1, type(list1))
# 输出：['a', 'b', 'c'] <class 'list'>

访问表元素

• 索引

  与字符串类似，列表可以通过下标访问列表中的元素，下标从0开始计数。

  列表支持正向索引、负向索引。

  list1 = ["a", "b", "c", "d", "e", "f", "g", "h"]
  print(list1[0], list1[3], list1[-2])
  # 输出：a d g
  

• 切片

  切片是通过下标访问列表中的元素，切片可以取出一个子列表。

  语法格式：

  list [ start : end : step ]
  

  • start表示切片的开始位置，默认为0。
  • end表示切片的终止位置（但不包含该位置的元素），默认为列表的长度。
  • step为切片的步长，默认为1，当省略步长时，可以同时省略后一个冒号;当步长为负数时，表示从end向start取值。

  如：

  list1 = ["a", "b", "c", "d", "e", "f", "g", "h"]
  print(list1[0:5])
  print(list1[6:3:-1])
  # 输出：
  # ['a', 'b', 'c', 'd', 'e']
  # ['g', 'f', 'e']
  

  还可以使用slice()函数来切片。语法格式和上面的切片方式类似。

  list1 = ["a", "b", "c", "d", "e", "f", "g", "h"]
  x = slice(0, 8, 3)
  print(list1[x])
  # 输出：['a', 'd', 'g']
  

• 遍历列表

  使用 for 循环来遍历列表项：

  list1 = ["a", "b", "c", "d", "e", "f", "g", "h"]
  for i in list1:
      print(i, end=' ')
  # 输出：a b c d e f g h
  

添加元素

使用append()，insert()，extend()函数来添加列表元素。

• append()函数

  用于在列表的末尾追加新的元素，无返回值。如：

  list1 = ["a", "b", "c", "d", "e", "f", "g", "h"]
  list1.append("g")
  print(list1)
  # 输出：['a', 'b', 'c', 'd', 'e', 'f', 'g', 'h', 'g']
  

• insert()函数

  用于在列表的中间插入元素，无返回值。

  语法格式：

  list.insert(index, obj)
  

  其中，index是要插入元素的索引，obj是要插入的元素。如：

  list1 = ["a", "b", "c", "d", "e", "f", "g", "h"]
  list1.insert(3, "i")
  print(list1)
  # 输出：['a', 'b', 'c', 'i', 'd', 'e', 'f', 'g', 'h']
  

• extend()函数

  用于在列表末尾一次性追加另一个序列中的多个值（用新列表扩展原来的列表），无返回值。

  注意，extend()内追加的元素必须是可转换为list的类型的元素。

  list1 = ["a", "b", "c", "d", "e", "f", "g", "h"]
  str1 = "hello"
  list1.extend(str1)
  print(list1)
  # 输出：['a', 'b', 'c', 'd', 'e', 'f', 'g', 'h', 'h', 'e', 'l', 'l', 'o']
  

删除元素

删除列表元素有多种方法。

• pop方法

  语法格式：

  pop(index)
  

  使用index指定索引来删除元素，若不指定索引则删除最后一个。

  如：

  list1 = ["a", "b", "c", "d", "e", "f", "g", "h"]
  list1.pop()
  print(list1)
  list1.pop(1)
  print(list1)
  # 输出：
  # ['a', 'b', 'c', 'd', 'e', 'f', 'g']
  # ['a', 'c', 'd', 'e', 'f', 'g']
  

• remove方法

  语法格式：remove(obj)

  remove用于指定删除的数据，若指定的数据不存在则会报错。

  如：

  list1 = ["a", "b", "c", "d", "e", "f", "g", "h"]
  list1.remove("a")
  print(list1)
  list1.remove("hello")
  # 输出：
  # ['b', 'c', 'd', 'e', 'f', 'g', 'h']
  # 错误
  

• del方法

  与pop()方法类似，del方法也是根据下标删除，但是del方法没有返回值而pop方法有

  del方法必须指定索引。

  语法格式：

  del list[index]
  

  如：

  list1 = ["a", "b", "c", "d", "e", "f", "g", "h"]
  del list1[1]
  print(list1)
  # 输出：['a', 'c', 'd', 'e', 'f', 'g', 'h']
  

• clear方法

  clear()会直接清空列表中的所有元素。

  语法格式：

  list.clear()
  

  如：

  list1 = ["a", "b", "c", "d", "e", "f", "g", "h"]
  list1.clear()
  print(list1)
  # 输出： []
  

修改表元素

• 通过对列表索引的元素重新赋值来修改列表元素，即下标和切片。

list1 = ["a", "b", "c", "d", "e", "f", "g", "h"]
list1[1] = "aaa"
print(list1)
list1[1:3] = ['1', '2']
print(list1)
# 输出：
# ['a', 'aaa', 'c', 'd', 'e', 'f', 'g', 'h']
# ['a', '1', '2', 'd', 'e', 'f', 'g', 'h']

• 反转列表

要反转列表，使用reverse()方法。

list1 = ["a", "b", "c", "d", "e", "f", "g", "h"]
list1.reverse()
print(list1)
# 输出： ['h', 'g', 'f', 'e', 'd', 'c', 'b', 'a']

• 排序列表

对列表内的元素进行排序（排序列表的数据类型需一致）可以使用sort()方法，它会修改原来的列表而不是返回一个新的排序列表；若要返回一个新列表，可以使用sorted()方法。

语法格式如下。

list.sort(key=None, reverse=False)

其中，key和reverse都是可选参数：

• key：指定用于排序的比较函数。默认情况下，sort()方法使用自然排序（即按照数字和字母的顺序进行排序）。
• reverse：指定排序方式。默认情况下，reverse=False表示按照升序排序，reverse=True表示按照降序排序。

如：

# 对列表进行升序排序
list1 = [3, 1, 4, 1, 5, 9, 2, 6, 5, 3, 5]
sorted_list = sorted(list1)
print(sorted_list)
# 输出：[1, 1, 2, 3, 3, 4, 5, 5, 5, 6, 9]

# 对列表进行降序排序
list1 = [3, 1, 4, 1, 5, 9, 2, 6, 5, 3, 5]
sorted_list = sorted(list1, reverse=True)
print(sorted_list)
# 输出：[9, 6, 5, 5, 5, 4, 3, 3, 2, 1, 1]

# 对字符串列表进行排序
list1 = ["apple", "orange", "banana", "pear"]
sorted_list = sorted(list1, key=lambda x: len(x))
print(sorted_list)
# 输出：['pear', 'apple', 'orange', 'banana']

复制列表

使用list2 = list1 来复制列表，但是list2 将只是对 list1 的引用，对list1的更改也会作用与list2上。

list1 = ["a", "b", "c"]
list2 = list1
print(id(list1))
print(id(list2))
# 输出：
# 2254690297600
# 2254690297600

可以看到，list1和list2的内存地址一样，表示二者是同一个对象。

若要复制列表内容，则可以使用copy()方法。

list1 = ["a", "b", "c"]
list2 = list1.copy()
print(id(list1))
print(id(list2))
# 输出：
# 1953045194816
# 1953045057856

判断成员关系

当我们需要判断一个元素是否属于一个列表时，可以使用in和not in运算符。

需要注意的是，in和not in运算符只能用于判断单个元素是否在列表中。如果需要判断多个元素是否在列表中，可以使用循环结构或集合（set）来实现。

• in：如果一个元素属于列表，返回True；否则返回False。
• not in：如果一个元素不属于列表，返回True；否则返回False。

list1 = [1, 2, 3, 4, 5]
# 判断元素是否在列表中
print(3 in list1)    # 输出 True
print(6 in list1)    # 输出 False

# 判断元素是否不在列表中
print(3 not in list1)    # 输出 False
print(6 not in list1)    # 输出 True

统计方法

• 获取列表中元素的个数

使用len()方法来获取列表中元素的个数：

list1 = ["a", "b", "c", "d", "e", "f", "g", "h"]
print(len(list1))
# 输出：8

• 统计字符串出现的次数

使用count()方法来统计字符串出现的次数：

list1 = ['apple', 'banana', 'cherry', 'apple', 'banana', 'apple']
count = list1.count('apple')
print(count)
# 输出：3

• 统计字符串第一次出现的位置

使用index()方法来统计字符串第一次出现的次数，输出结果为索引位置。

list1 = ['apple', 'banana', 'cherry', 'apple', 'banana', 'apple']
print(list1.index('banana'))
# 输出：1

元组

元组（tuple）是一个有序的集合，可以存放任意数据类型，但是元组中的元素不能被修改，添加或删除。使用圆括号( )来创建一个元组。

若要创建一个只有一个元素的元组，需要在元素后加上逗号,。如果不加逗号，括号可能被当做是运算符，导致创建的不是元组，而是一个单独的对象。

my_tuple1 = () # 空元组
my_tuple2 = (1, 2, 3)
my_tuple3 = (1,)

访问元素

与列表类似，访问元组元素也是通过索引和切片。

my_tuple = ("a", "b", "c", "d", "e", "f", "g", "h")
print(my_tuple[0], my_tuple[3], my_tuple[-2])
# 输出：a d g

修改元素值

虽然元组本身是不可变的，当元组中存放可变数据类型元素的时候，那这个元素是可以改变的。

my_tuple = ([1, 2, 3], 'hello', 100)
my_tuple[0][1] = 4
print(my_tuple)
# 输出：([1, 4, 3], 'hello', 100)

连接元组

元组中的元素值是不允许修改的，但我们可以对元组进行连接组合，使用加号运算符来连接两个元组，返回一个新的元组。

my_tuple1 = (1, 2, 3)
my_tuple2 = ('hello',)
my_tuple3 = my_tuple1 + my_tuple2
print(my_tuple3)
# 输出：(1, 2, 3, 'hello')

重复元组

使用乘号运算符来将一个元组重复多次，返回一个新的元组。

my_tuple1 = (1, 2, 3)
print(my_tuple1 * 3)
# 输出：(1, 2, 3, 1, 2, 3, 1, 2, 3)

获取元素个数

可以使用 len()方法来获取元组中元素的个数。如：

my_tuple1 = (1, 2, 3)
print(len(my_tuple))
# 输出：3

判断成员关系

使用in和not in来判断元素是否在元组中。

my_tuple = (1, 2, 3, 4, 5)
# 判断元素是否在元组中
print(3 in my_tuple)  # 输出 True
print(6 in my_tuple)  # 输出 False

# 判断元素是否不在元组中
print(3 not in my_tuple)  # 输出 False
print(6 not in my_tuple)  # 输出 True

集合

集合（set）是一个无序的不重复元素序列。使用大括号 { } 或者set()函数创建集合。

注意：创建一个空集合必须用set()而不是 { }，因为 { } 是用来创建一个空字典。

my_set1 = {1, 2, 3, 'a', 'b', 'c'}
my_set2 = set([1, 2, 3, 'a', 'b', 'c'])
print(my_set1)
print(my_set2)
# 输出：
# {'b', 2, 3, 1, 'a', 'c'}
# {'b', 1, 2, 3, 'a', 'c'}

注意，集合是一种无序的可迭代对象，因此集合中元素的顺序是不确定的。当打印这个集合时，Python会根据一些内部规则来决定如何排序和显示元素。

访问元素

由于集合中的元素是无序的，因此无法向列表那样使用下标访问元素。访问集合元素最常用的方法是使用循环结构，将集合中的数据逐一读取出来。

my_set = {1, 2, 3, 'a', 'b', 'c'}
for i in my_set:
    print(i,end=' ')
# 输出结果：c 1 2 3 b a 

添加元素

• add()方法

  使用add()方法向集合中添加单个元素，使用 add() 方法只能添加不可变数据类型。如果集合中已经存在相同的元素，则 add() 方法不会添加新元素。

  my_set = {1, 2, 3, 'a', 'b', 'c'}
  my_set.add(4)
  print(my_set)
  # 输出：{1, 2, 3, 'a', 4, 'b', 'c'}
  

该方法的语法格式为：

• upgrade()方法

  upgrade()方法可以添加多个对象，并且接受任何可迭代对象作为参数，包括列表，元组和其他集合。

  my_set = {1, 2, 3}
  my_list = [4, 5, 6]
  my_set.update(my_list)
  print(my_set)
  # 输出：{1, 2, 3, 4, 5, 6}
  

删除元素

• remove()方法

  使用remove()方法删除集合中的指定元素，如果指定元素不存在则会报错。

  my_set = {1, 2, 3, 'a', 'b', 'c'}
  my_set.remove(1)
  print(my_set)
  # 输出：{2, 3, 'a', 'c', 'b'}
  

• discard() 方法

  此方法和 remove() 方法的用法完全相同，唯一的区别就是，当指定元素不存在时，此方法不会抛出任何错误。

• pop()方法

  此方法会随机删除集合中的一个元素，并返回该元素的值；若集合中不存在元素则会报错。

  my_set = {1, 2, 3, 'a', 'b', 'c'}
  del_set = my_set.pop()
  print(del_set)
  # 输出：b
  

• clear()方法**

  此方法会直接清空集合，用法与列表的clear()方法一致。

判断成员关系

使用in和not in来判断元素是否在集合中。

my_set = {1, 2, 3, 'a', 'b', 'c'}
print(1 in my_set) # True
print(4 in my_set) # False
print(1 not in my_set) #False
print(4 not in my_set) #True

集合运算

集合运算是用来处理集合的操作，包括交集、并集、差集、对称差集等。

以set1={1,2,3}，set2={3,4,5}为例：

运算操作	Python运算符	含义	示例
交集	&	取两集合公共重复的元素	set1 & set2 —> {3}
并集	|	取两集合全部的元素	set1 | set2 —> {1,2,3,4,5}
差集	-	从一个集合中去除另一个集合中的元素，得到一个新的集合	set1 - set2 —> {1,2}
对称差集	^	取两个集合的并集中不属于集合交集的元素，即两个集合之间不重复的元素	set1 ^ set2 —> {1,2,4,5}

字典

字典（dictionary）是一种无序、可变、可迭代的键值映射的数据结构。

字典的每个键值对用冒号 : 分割，每个键值对之间用逗号 , 分割，整个字典包括在花括号 { }中。

字典的键必须唯一、不可重复，必须为不可变数据类型。

语法格式如下：

my_dict = {'key1': 'value1', 'key2': 'value2'} # 大部分习惯使用
my_dict = dict(key1='value1', key2='value2')

访问字典元素

• 通过键来访问字典元素

  与列表和元组不同，要访问字典元素，需要通过键。使用key()函数来获得字典的所有键。

如：

my_dict = {"name": "abc", "age": 18, "class": "1"}
print(my_dict.keys())
print(my_dict["name"])
print(my_dict["xxx"])  # 不存在键会报错
# 输出：
# dict_keys(['name', 'age', 'class'])
# abc
# 错误

• 通过get()方法来访问字典元素

语法格式如下：

dict.get(key, none)

当get()方法没有取到键的值时，会返回默认值None，也可以自行指定其他值。

my_dict = {"name": "abc", "age": 18, "class": "1"}
print(my_dict.get("name"))
print(my_dict.get("xxx"))  # 不存在会输出None
print(my_dict.get("name", "aaa"))  # 取到了name的值则返回name，没有取到则返回aaa
print(my_dict.get("xxx", "null"))  # 没有取到值返回null
# 输出：abc None abc  null

• 遍历字典

在使用for循环遍历字典时，默认遍历的是字典的key；若需同时访问字典的key和value，需要使用两个遍历来接收。

my_dict = {"name": "abc", "age": 18, "class": "1"}
for i in my_dict:
    print(i)  # 输出key
for i in my_dict.values():
    print(i)  # 输出value
for i in my_dict.items():
    print(i)  # 输出key和value的元组
for k, v in my_dict.items():  # 使用两个变量分别接收key和value
    print(f"{k}-->{v}")
# 输出：
# name age class
# abc 18 1
# ('name', 'abc') ('age', 18) ('class', '1')
#name-->abc age-->18 class-->1

添加和修改字典元素

通过访问修改字典的键值来修改元素，若元素不存在则新建，存在则修改。

my_dict = {"name": "abc", "age": 18, "class": "1"}
my_dict["name"] = "aaa" # 存在name键，修改值
my_dict["score"] = 80 # 不存在score键，新建键值对
print(my_dict)
# 输出：{'name': 'aaa', 'age': 18, 'class': '1', 'score': 80}

删除字典元素

使用del关键字来删除字典的键值对。

del my_dict["name"]

使用clear()方法来清空字典。

my_dict.clear()

判断成员关系

使用in和not in来判断元素是否在字典中。默认情况下，判断的是元素是否在字典的key中；使用values()来判断元素是否在字典的value中。

my_dict = {"name": "abc", "age": 18, "class": "1"}
print("name" in my_dict)
print("xxx" in my_dict)
print(18 in my_dict.values())
# 输出：True False True