组合数据类型

组合数据类型是用于将多个数据元素组织在一起的数据结构，如列表、元组、字典。

列表型

什么是列表

编程中, 经常需要使用变量, 来保存/表示数据.

如果代码中需要表示的数据个数比较少, 我们直接创建多个变量即可.

但是有的时候, 代码中需要表示的数据特别多, 甚至也不知道要表示多少个数据. 这个时候, 就需要用到 列表.

列表是一种让程序员在代码中批量表示/保存数据的方式

如何创建列表

#创建列表的两种方式，常用第一种
alist = [] #方法1
alist = list() #方法二
print(type(alist))

需要注意的是：列表中存放的元素允许是不同的类型. (这一点和 C++ Java 差别较大).
因为Python是动态类型语言，列表本质上存储的是对象的引用（内存地址），而不是固定类型 的数据。这意味着列表可以同时包含整数、字符串、字典等任意类型的对象，每个元素都可以指向不同的数据类型。

a = [1,3.14,"zhangsan",True]

访问下标操作

我们可以通过下标访问操作符 [ ] 来获取到列表中的任意元素.(下标也是从0开始，这点同C++ Java)

a = [1,3.14,"zhangsan",True]
print(a[2])
print(a[-1])

输出结果：

• python中，访问下标可以是负数，如a[-1] 就是访问 a[len(a)-1] 也就是 a[3]

a = [1,3.14,"zhangsan",True]
a[1]="lisi"
a[3]=999
print(a)

• 通过下标不光 能读取元素内容, 还能修改元素的值.

输出结果：

切片操作

• 通过下标操作是一次取出里面第一个元素.
• 通过切片, 则是一次取出一组连续的元素, 相当于得到一个 子列表

arr = [1,2,3,4,5]
print(arr[1:3])

输出结果：

arr[1:3] 中的 1:3 表示的是 [1, 3) 这样的由下标构成的左闭右开区间.

• 切片操作中可以省略前后边界

arr = [1,2,3,4,5]
print(arr[:])
print(arr[1:])
print(arr[:4])

输出结果：

• 切片操作还可以指定 “步长” , 也就是 “每访问一个元素后, 下标自增几步”(当步长为负数时，是从后往前进行取元素. 表示 “每访问一个元素之后, 下标自减几步”)

arr=[1,2,3,4,5,6]
print(arr[::1])
print(arr[::2])
print(arr[::-1])

输出结果：

遍历操作

指的是把元素一个一个的取出来, 再分别进行处理.

• 直接for循环(最简单最常用)

alist=[1,2,3,4,5]
for x in alist:
    print(x)

• for 按照范围生成下标, 按下标访问

alist=[1,2,3,4,5]
for x in range(0,len(alist))
	print(alist(x))

• while 循环. 手动控制下标的变化新增

alist=[1,2,3,4,5]
i=0
while(i<len(alist))
   print(alist(i))
   i+=1

新增元素

• 使用 append 方法, 向列表末尾插入一个元素(尾插).

alist=[1,2,3,4]
alist.append("hello")
print(alist)

输出结果：

• 使用 insert 方法, 向任意位置插入一个元素

alist=[1,2,3,4,6]
alist.insert(2,"word")
print(alist)

输出结果：

查找元素

• 使用 in 操作符, 判定元素是否在列表中存在. 返回值是布尔类型.

alist=[1,2,3,4,3.14,"hello"]
print(3.14 in alist)
print(5 in alist)

输出结果：

• 使用 index 方法, 查找元素在列表中的下标. 返回值是一个整数. 如果元素不存在, 则会抛出异常.

alist=[1,2,3,4,3.14,"hello"]
print(alist.index("hello"))
print(alist.index(12))

删除元素

• 使 pop 方法删除末尾元素还可通过下标删除特定元素

alist=[1,2,3,4,3.14,"hello"]
alist.pop()
alist.pop(3)
print(alist)

输出结果：

• 使用 remove 方法, 按照值删除元素.

alist=[1,2,3,4,3.14,"hello"]
alist.remove(2)
alist.remove("hello")
print(alist)

连接元素

• 使用 + 能够把两个列表拼接在一起.

arr1=[1,2,3]
arr2=["one","two","three"]
print(arr1+arr2)

输出结果：

• 使用 extend 方法, 可以把一个列表拼接到另一个列表的后面.

arr1=[1,2,3]
arr2=["one","two","three"]
arr1.extend(arr2)
print(arr1)
print(arr2)

元组型

*列表和元组的区别？

元组的功能和列表相比, 基本是一致的.
为什么有了列表还要有元组呢，它们之间有什么区别?

举个例子啊，列表就像是我们平时吃的散装薯片，一袋的量是可变的，不够吃可以随时称量，比较灵活

而元组就像袋装或者筒装薯片，每一盒的量都是一定的，小袋不够吃只能买个大袋的

以下这个表总结了列表和元组的区别：

特性	列表 (List)	元组 (Tuple)
定义方式	[]，如 [1, 2, 3]	()，如 (1, 2, 3)
可变性	✅ 可变（可增删改元素）	❌ 不可变（创建后不能修改）
语法特点	使用方括号	使用圆括号
性能	稍慢（需动态管理内存）	更快（内存占用小）
常用场景	需要动态修改的数据集合	固定数据、函数返回多值、字典键
方法	丰富（append、remove、sort等）	很少（只有 count、index）
示例	list = [1, "a", 3.14]	tuple = (1, "a", 3.14)
是否可哈希	❌ 不可（不能作为字典键）	✅ 可（可作为字典键）

字典型

什么是字典

字典是Python中存储键值对的可变容器，通过唯一键快速查找对应的值。

什么是键值对

键(key) 和 值(value) 进行一个一对一的映射, 然后就可以根据键, 快速找到值.

键(key)相当于学生的学号，值(value)相当于这个学生，知道学号就能找到对应的学生

如何创建字典

• 创建空的字典使用 { } 表示字典.

a= {}#常用
b= dict()
print(type(a))
print(type(b))

输出结果：

• 可以在创建的同时指定初始值
• 键值对之间使用 , 分割, 键和值之间使用 : 分割.

student={
    "id":1,
    "name":"zhangsan"
}
print(student)

查找 key

使用 in 可以判定 key 是否在 字典 中存在. 返回布尔值.

student = {
    'id': 1,
    'name': 'zhangsan',
}
print('id' in student)
print('gender' in student)

输出结果：

• 使用 [ ] 通过类似于取下标的方式, 获取到元素的值. 只不过此处的 “下标” 是 key.

student = {
    "id": 1,
    "name": "zhangsan",
}
print(student["id"])
print(student["name"])

输出结果

新增/修改操作

• 使用 [ ] 可以根据 key 来新增/修改 value.
• 如果 key 不存在, 对取下标操作赋值, 即为新增键值对

student = {
    "id": 1,
    "name": "zhangsan",
}
student['gender']="m"
print(student)

输出结果：

• 如果 key 已存在, 对取下标操作赋值, 即为修改键值对.

student = {
    "id": 1,
    "name": "zhangsan",
}
student['name']="lisi"
print(student)

输出结果：

删除操作

• 使用 pop 方法根据 key 删除对应的键值对.

student = {
    "id": 1,
    "name": "zhangsan",
    "gender":"m"
}
student.pop("id")
print(student)

输出结果：

遍历字典

• 直接使用 for 循环获取到字典中的所有的 key, 进一步的就可以取出每个值.

student = {
    "id": 1,
    "name": "zhangsan",
    "gender":"m"
}
for key in student:
    print(key,student[key])

输出结果：

获取key和value

• 使用 keys 方法可以获取到字典中的所有的 key

student = {
    "id": 1,
    "name": "zhangsan",
    "gender":"m",
    "class":5
}
print(student.keys())

输出结果：

• 使用 values 方法可以获取到字典中的所有 value

student = {
    "id": 1,
    "name": "zhangsan",
    "gender":"m",
    "class":5
}
print(student.values())

输出结果：

• 使用 items 方法可以获取到字典中所有的键值对.

student = {
    "id": 1,
    "name": "zhangsan",
    "gender":"m",
    "class":5
}
print(student.items())

输出结果：

*什么是可哈希，哪些类型可哈希？

字典本质上是一个 哈希表, 哈希表的 key 要求是 “可哈希的”,
可哈希是指一个对象可以被计算出一个固定的哈希值，因此可以用作字典的键或集合的元素

• 可以使用 hash 函数计算某个对象的哈希值.但凡能够计算出哈希值的类型, 都可以作为字典的 key.

print(hash(10))
print(hash(3.14))
print(hash("zhangsan"))
print(hash(True))
print(hash(()))
print(hash([]))
print(hash({}))

输出结果：

由此我们可以总结出下表：

类型	是否可哈希	说明	示例
不可变类型
整数 (int)	✅ 是	数字不可变，哈希值稳定	hash(10)
浮点数 (float)	✅ 是	数字不可变	hash(3.14)
字符串 (str)	✅ 是	文本不可变	hash("zhangsan")
元组 (tuple)	✅ 是	所有元素必须可哈希	hash((1, 2, 3))
布尔值 (bool)	✅ 是	True/False 不可变	hash(True)
不可变类型（例外）
frozenset	✅ 是	冻结集合不可变	hash(frozenset([1, 2]))
可变类型
列表 (list)	❌ 否	可变，哈希值可能变化	hash([1, 2]) 报错
字典 (dict)	❌ 否	可变，哈希值可能变化	hash({"a": 1}) 报错
集合 (set)	❌ 否	可变，哈希值可能变化	hash({1, 2}) 报错
自定义类
默认类	❌ 否	可变对象不可哈希	class MyClass: pass
实现 __hash__	✅ 是	需配合 __eq__ 定义	class MyClass: def __hash__(self): ...

一些常考问题

列表和元组的区别？

列表可变（用 [] ），元组不可变（用 ( )）；列表性能稍慢，元组更快且可哈希。
2.
字典的键有什么要求？

键key必须可哈希（不可变类型，如字符串、数字、元组），且唯一。
3.
为什么列表中可以添加不同的数据类型？

Python是动态类型语言，列表存储对象引用，而非固定类型。
4.
什么是可哈希？

对象有固定哈希值，可用作字典键或集合元素；通常不可变类型可哈希。
5.
元组可以作为字典的键吗？

可以，但元组内的所有元素必须可哈希。
6.
列表和字典的性能差异？

列表适合顺序访问，字典适合键值查找，字典查找速度更快（O(1) vs O(n)）。
7.
如何判断一个对象是否可哈希？

使用 hash() 函数测试，或检查是否不可变。