人生苦短，我学python之数据类型（上）

个人主页：星纭-CSDN博客

系列文章专栏：Python

踏上取经路，比抵达灵山更重要！一起努力一起进步！ 

目录

一.元组 （tuple）

二.集合（set）

 三.字典(dict)

---

一.元组 （tuple）

通过之前的学习我们了解了很多数据类型，比如整形(int),浮点数(float),字符串(str),列表(list)等等，接下来我们继续学习其他的数据类型。

student = ('20240506', '张三', '95')
print(student, type(student))  # 输出('20240506', '张三', '95') <class 'tuple'>

student的数据类型是元组，它与列表有所不同，列表是使用方括号定义的，元组是使用圆括号，并且使用逗号进行隔开。

观察以下代码：

a = (1, 2, 3, 1, 3, 1)
print(len(a))
print(a[1:3])
print(a.count(1))
print(4 in a)
print(max(a), min(a), sum(a))
print(a + a, a * 3)

输出结果：

('20240506', '张三', '95') <class 'tuple'>
6
(2, 3)
3
False
3 1 11
(1, 2, 3, 1, 3, 1, 1, 2, 3, 1, 3, 1) (1, 2, 3, 1, 3, 1, 1, 2, 3, 1, 3, 1, 1, 2, 3, 1, 3, 1) 

我们不难发现，以上对于元组的操作，对于列表也是成立的，二者一模一样。那么为啥还要有元组这样的数据类型呢？

其实元组也有不同于列表的性质。

注意一个细节：

a = (1)
print(type(a))  # 输出<class 'int'>

如果我们的元组只有一个元素，仅仅使用(1)这样的操作会让编译器理解为一个整数被括号括起来了，并不是元组，而且编译器会提示你使用括号括起整数这样的操作是毫无意义的。

并且提示你删除冗余的括号。

那么如果定义一个只有一个元素的元组呢？ 

a = (1,)

只需要再添加一个逗号即可。

然后回到最开始的问题，元组和列表的区别在哪里？

元组和列表的主要区别在于元组是不可变的，而列表是可变的。

换句话说，元组（tuple）是只读的列表，这里的只读就代表不可更改。 

所谓只读，就是指一个元组被创建后，其元素是可以获取的，但是不能修改。

有人就会问了，那上面的切片操作如何解释呢？

注意：切片并不会导致 原始列表或者元组被修改，其只会创建一个新的列表或者元组。

所以对于元组来说，sort(),remove(),clear()函数都是不适用于元组的。

tuple()函数可以用于将对象转化为元组。 

a = tuple([1, 2, 3])
ch = tuple('abc')
num = tuple(x for x in range(10))
print(a, ch, num)  # 输出(1, 2, 3) ('a', 'b', 'c') (0, 1, 2, 3, 4, 5, 6, 7, 8, 9)

注意：元组并不是使用括号就是元组的

list1 = [x for x in range(10)]
tuple1 = (x for x in range(10))
print(list1, tuple1)

输出结果：

[0, 1, 2, 3, 4, 5, 6, 7, 8, 9] <generator object <genexpr> at 0x0000020AC37EFED0>

很明显tuple1并不是元组，具体这个是什么，后面会进一步讲解。 

二.集合（set）

这里学的集合与数学上的集合并不相同。

Python中的集合是一种无序、可变的容器，它由不重复的元素组成。

不同于列表，集合中的元素是不允许重复的，元素是无序的不分前后关系。 、

集合是通过花括号{}创建的，元素之间使用逗号分隔。

创建集合：可以使用花括号{}或set()函数来创建一个集合。

s1 = {1, 2, 3, 4, 5}
s2 = set([1, 2, 3, 4, 5])
print(s1, s2)  # 输出{1, 2, 3, 4, 5} {1, 2, 3, 4, 5}
print(type(s1), type(s2))  # 输出<class 'set'> <class 'set'>

add()函数可以用于向集合中加入元素：

s = {1, 2, 3}
s.add(4)

remove()函数可以移除集合中的元素

s = {1, 2, 3}
s.remove(2)

需要注意的是;如果要删除的元素不存在，会抛出KeyError异常。

有没有如果不存在但是不会抛出异常的函数呢？

a = {1, 2, 3, 4, 5}
a.discard(6)

discard函数对于集合就不会抛出异常。 

pop函数是用于弹出一个元素并返回，但是由于集合是无序的，所以它在弹出的时候的元素是完全随机的。

a = {-1, 0, 1, 2, 3, 4, 5}
a.pop()
print(a)  # 输出{1, 2, 3, 4, 5, -1}

 三.字典(dict)

 在学习字典之前，先来看这样一个问题，如何创建一个空集合？

a = {}
b = set([])

 a还是b呢？

注意：创建一个空集合必须使用set()函数来进行，因为{}是用于创建字典的。

输出结果：print(type(a), type(b))         <class 'dict'> <class 'set'>

字典是一种无序的数据结构，用于存储键值对。字典是通过花括号{}来表示的，每个键值对之间用逗号分隔。键必须是唯一的，而值可以是任意类型的对象。

什么是键值对呢？

键值对是计算机中一种非常重要的概念。

每一个键都对应着一个值，通过这个值我们就可以清楚的找到这个值。

 比如通过学号可以轻易找到某个学生，通过电话号码可以找到某个人。这里的学号和电话号码就是键，学生和人可以理解为值。这是一种映射关系

键值对是一种数据结构，它是由一个键和一个相应的值组成的。键和值之间存在一一对应的关系。键用于唯一标识值，值则存储相应的数据。在键值对中，键是唯一的，不重复的，而值可以是任意类型的数据，比如字符串、数字、对象等。键值对常用于存储和表示数据，可以通过键来快速访问和查找对应的值。

为啥键必须是唯一的呢？，因为要通过键找到一个准确的值，如果键不唯一，那么就会出现找到多个的情况。但是值可以不唯一，比如一个人可以拥有多个手机号。 

这里的字典，其实和现实生活中的字典很类似，比如有一个英文单词不认识，这个单词就是key，中文翻译就是value

那么如何定义一个字典呢？

a = {
    1: 'zhangsan',
    2: 'zhangsan',
    4: 'lishi',
    5: 'wangwu'
}

至于为啥，不把这个字典写在一行，是因为，为了方便观察。最后一个键值对的逗号可写可不写。

那么如何通过键来找到值呢？这里还是要用到[ ]操作符

a = {
    'id': 1,
    'name': 'zhangsan',
    'score': 99
}
print(a['id'], a['name'], a['score'])  # 输出1 zhangsan 99

在字典中，key的类型不一定都一样 ，而且key的类型是有所限制的，key的数据类型可以是不可变的数据类型，例如整数、浮点数、字符串、元组等。不能作为字典的key的数据类型是可变的数据类型，例如列表和字典。如果你使用了可变的数据类型，在使用的时候会报错：

TypeError: unhashable type: 'list'

value就比较随意了既不必都一样，也没有限制，什么都可以。

# not in 来判定 key 在字典中不存在

# in 来判定 key 在字典中不存在

这里的判断只能判读key，于value无关。

a = {
    'id': 1,
    'name': 'zhangsan',
    'score': 99
}
print('id' in a)
print(1 not in a)

 对于字典来说，使用in和[]这样的操作均是非常高效的，而对于列表来说使用in是非常低效的，而使用[]是非常高效的。

因为对于列表来说使用in会遍历整个列表，直到找到要的元素，而字典底层采用了特殊的数据结构哈希表，所以非常高效，这部分内容我们后续还会继续讲解。

遍历指的是，把一个可迭代对象，里面包含的元素依次取出，来进行一些操作，整个过程要求不重不漏

# 直接使用 for 循环来遍历字典
a = {
    'name': 'zhangsan',
    'id': 1,
    'score': 90
}

for key in a:
    print(key, a[key])

输出结果：name zhangsan
id 1
score 90 

# 这个操作就是往字典里插入新的键值对.
a['score'] = 90
print(a)

# 2. 在字典中, 根据 key 修改 value, 也是使用 [ ] 来进行的~
a['score'] = 100
print(a)

# 3. 使用 pop 方法, 根据 key 来删除键值对~
a.pop('name')
print(a)

对于插入和修改来说，如果key不存在就是插入，如果存在了就是修改。

比如：

a = 10
a = 20

第一个代码就是创建变量，第二行代码就是修改变量的值。

注：字典的各种操作都是针对key来进行的，增加，删除，获取，修改value 

字典也有几个成员函数：keys,values,items

这几个函数的功能分别是返回key，value,和整个键值对

print(a.keys())
print(a.values())
print(a.items())
# dict_keys(['name', 'id', 'score'])
# dict_values(['zhangsan', 1, 90])
# dict_items([('name', 'zhangsan'), ('id', 1), ('score', 90)])

不难发现，每一对键值对其实是一个元组

 字典，元组，集合都是python中非常常用的数据类型，他们的内部可以包含其他的数据类型。

在Python中，哈希函数是一种用于将任意大小的数据映射到固定大小值的函数。哈希函数通常用于检查数据的完整性和验证数据的唯一性。

Python提供了许多内置的哈希函数，如md5、sha1、sha256等。这些哈希函数是通过在输入数据上运行特定的算法来生成固定长度的哈希值。

# 使用 hash 函数能够计算出一个变量的哈希值.
print(hash(0))
print(hash(3.14))
print(hash('hello'))
print(hash(True))
print(hash((1, 2, 3)))

集合内的元素就必须是可哈希的数据类型，这样的类型一般情况下是只读的。

注意：集合不是可哈希的类型 。

# 有的类型是不能计算哈希值的.
print(hash([1, 2, 3]))
print(hash({ }))

如果分别运行以上两行代码，就会抛出异常：

TypeError: unhashable type: 'list'

 TypeError: unhashable type: 'dict'

意思分别是，列表不是可哈希类型，字典不是可哈希类型。