Python基础（三） 组合类型

组合类型

有序

列表

列表的特征

• 列表的所有元素放在一对（[ ]）内，相邻元素之间用逗号分隔；
• 列表没有长度限制，不需要预定义长度；元素类型可以不同，可以放其他列表；
• 列表中的元素是有序的，这意味着每个元素都有一个固定的位置，称为索引。第一个元素的索引是0，第二个是1，依此类推。负索引用于从末尾开始计数，例如，-1 表示最后一个元素，-2 表示倒数第二个元素；
• 线性的数据结构；
• 列表是可变的，这意味着可以修改列表中的元素、添加新元素或删除元素。这与字符串不同，字符串是不可变的。

列表的创建

# 创建一个空列表
empty_list = []

# 创建一个包含整数的列表
int_list = [1, 2, 3, 4, 5]

# 创建一个包含不同类型元素的列表
mixed_list = [1, "hello", 3.14, [1, 2, 3]]

# 创建一个嵌套列表（列表中的元素也是列表）
nested_list = [[1, 2], [3, 4], [5, 6]]

列表的访问

从前往后的正向索引，n 个元素，索引值从 0 到 n-1；
从后往前的反向索引，n 个元素，索引值从 -1 到-n。

# 创建一个包含整数的列表
int_list = [1, 2, 3, 4, 5]
# 访问列表中的第一个元素（索引从0开始）
first_element = int_list[0]  # 1
print(first_element)
# 访问列表中的最后一个元素
last_element = int_list[-1]  # 5
print(last_element)
# 创建一个嵌套列表（列表中的元素也是列表）
nested_list = [[1, 2], [3, 4], [5, 6]]
# 访问嵌套列表中的元素
nested_element = nested_list[1][1]  # 4
print(nested_element)

列表的方法

Python 列表有很多内置方法，用于操作和处理列表中的元素。以下是一些常用的方法：

• append(x)：在列表末尾添加元素 x。
• insert(i, x)：在索引 i 位置插入元素 x。
• remove(x)：删除列表中的第一个值为 x 的元素。
• clear()：删除列表中的所有元素。
• index(x, [start, [end]])：返回列表中第一个值为 x 的元素的索引，如果没有找到会引发 ValueError 异常。
• count(x)：返回元素 x 在列表中出现的次数。
• reverse()：就地反转列表中的元素。
• copy()：返回列表的浅复制。
• pop([i])：删除并返回索引 i 处的元素，如果不指定索引，删除并返回最后一个元素。
• sort(key=None, reverse=False)：就地排序列表中的元素。

# 创建列表
numbers = [1, 2, 3, 4, 5]

# 添加元素
numbers.append(6)
print(numbers)  # [1, 2, 3, 4, 5, 6]

# 返回元素个数
print(numbers.count(1))   # 1
# 插入元素
numbers.insert(2, 2.5)
print(numbers)  # [1, 2, 2.5, 3, 4, 5, 6]

# 删除元素
numbers.remove(2.5)
print(numbers)  # [1, 2, 3, 4, 5, 6]

# 弹出元素
popped = numbers.pop()
print(popped)  # 6
print(numbers)  # [1, 2, 3, 4, 5]

# 列表排序
numbers.sort(reverse=True)
print(numbers)  # [5, 4, 3, 2, 1]

列表支持的运算符

list = [1, 2, 3]
list = list +[4]
print (list)        # [1, 2, 3, 4]
list +=[5]
print(list)         # [1, 2, 3, 4, 5]

list1 = [1,2]
list2 = list1 * 2
print(list2)        # [1, 2, 1, 2]
list1 *= 2
print(list1)        # [1, 2, 1, 2]

元组

特点

• 所有元素放在圆括号（()）内；
• 元组中的元素是有序的，每个元素都有一个固定的位置，可以通过索引访问。
• 元组中的元素时不可变的，元组一旦创建，其中的元素不能被修改、添加或删除。
• 元组可以包含不同类型的元素，例如整数、字符串、列表，甚至是其他元组。
• 支持双向索引。

无序

字典

特点

• 字典是无序的，这意味着字典中的元素没有特定的顺序。
• 字典中的每个元素是一个键值对，包括一个键和一个值。键是唯一的，值可以是任意类型。
• 字典是可变的，可以修改、添加和删除键值对。
• 字典中的键必须是唯一的，如果同一个键被赋予新值，旧值会被覆盖。键必须是不可变类型，例如字符串、数字或元组。
• 用花括号（{}）表示。

字典元素的访问

字典中的值是通过键来访问值，如果键不存在，则抛出异常。

person = {
    "name": "Alice",
    "age": 25,
    "city": "New York"
}
print(person["name"])       #  Alice
print(person["tel"])        #  KeyError: 'tel'

字典的常用方法

• keys()：返回所有键的视图。
• values()：返回所有值的视图。
• items()：返回所有键值对的视图。
• update(other_dict)：将其他字典的键值对更新到当前字典中。
• clear()：清空字典。
• get(key,default):键存在则返回相应值，不存在则返回默认值default。
• popitem():随机从字典取出一个键值对，以元组形式返回，同时将该键值对从字典中删除。

# 创建一个示例字典
person = {
   "name": "Alice",
   "age": 25,
   "city": "New York"
}
print(person.popitem())         # 输出: ('city', 'New York')
print(person)                   # 输出: {'name': 'Alice', 'age': 25}  
print(person.get("name"))     # 输出: Alice
# 获取所有键
print(person.keys())  # 输出: dict_keys(['name', 'age', 'city'])
# 获取所有值
print(person.values())  # 输出: dict_values(['Alice', 25, 'New York'])
# 获取所有键值对
print(person.items())  # 输出: dict_items([('name', 'Alice'), ('age', 25), ('city', 'New York')])
# 更新字典
person.update({"age": 30, "country": "USA"})
print(person)  # 输出: {'name': 'Alice', 'age': 30, 'city': 'New York', 'country': 'USA'}
# 清空字典
person.clear()
print(person)  # 输出: {}

集合

特点

• 集合中的元素是无序的，这意味着元素没有特定的顺序，也不能通过索引访问元素。
• 集合中的每个元素都是唯一的，没有重复的元素。
• 用花括号（{}）表示；
• 集合是可变的，可以添加和删除元素，但集合中的元素必须是不可变的（如数字、字符串和元组）。
• 可使用 set() 创建空的集合。

集合操作方法

• add(element)：向集合中添加元素。
• remove(element)：从集合中删除元素，元素不存在则引发 KeyError。
• discard(element)：从集合中删除特定元素，元素不存在也不会引发错误。
• pop()：删除并返回一个任意元素，集合为空时引发 KeyError。
• clear()：清空集合。
• update({,})：新增集合元素

# 创建集合
fruits = {"apple", "banana", "cherry"}
# 添加元素
fruits.add("orange")
print("添加元素后的集合:", fruits)  # 输出: {'apple', 'banana', 'cherry', 'orange'}

fruits.remove("banana")
print("删除元素后的集合:", fruits)  # 输出: {'apple', 'cherry', 'orange'}

print(fruits.pop())             # 输出: orange
print(fruits)                   # 输出: {'cherry', 'apple'}
# 清空集合
fruits.clear()
print(fruits)                  # 输出: set()

集合 4 个操作符及运算

• 并集：并集运算符 | 或方法 union() 用于返回两个集合的并集，即包含两个集合中所有不同元素的新集合。
• 交集：交集运算符 & 或方法 intersection() 用于返回两个集合的交集，即包含两个集合中都存在的元素的新集合。
• 差集：差集运算符 - 或方法 difference() 用于返回两个集合的差集，即包含在第一个集合但不包含在第二个集合中的元素的新集合。
• 对称差集：对称差集运算符 ^ 或方法 symmetric_difference() 用于返回两个集合的对称差集，即包含在两个集合中但不同时包含于两者中的元素的新集合。

set1 = {1, 2, 3}
set2 = {3, 4, 5}

# 并集
union_set = set1 | set2
print(union_set)  # 输出: {1, 2, 3, 4, 5}
# 交集
intersection_set = set1 & set2
print(intersection_set)  # 输出: {3}
# 差集
difference_set = set1 - set2
print(difference_set)  # 输出: {1, 2}
# 对称差集
symmetric_difference_set = set1 ^ set2
print(symmetric_difference_set)  # 输出: {1, 2, 4, 5}