Python课堂笔记-第七讲（元组&字典&集合）

• 一、元组
• 1. 元组简介
• 2. 元组的基本使用
• 3. 元组的内置函数
• 4. 元组运算符

• 1. 字典的基本介绍
• 2. 字典的使用
• 3. copy()浅复制
• 4. 遍历字典

• 1. 集合简介
• 2. 集合的运算

一、元组

1. 元组简介

Python的元组与列表类似，不同之处在于元组的元素不能修改。
元组使用小括号，列表使用方括号。
元组创建很简单，只需要在括号中添加元素，并使用逗号隔开即可。

tup1 = (\'physics\', \'chemistry\', 1997, 2000)tup2 = (1, 2, 3, 4, 5 )tup3 = \"a\", \"b\", \"c\", \"d\"

创建空元组

tup1 = ()

元组中只包含一个元素时，需要在元素后面添加逗号

tup1 = (50,)

2. 元组的基本使用

2.1 访问元组

元组与字符串类似，下标索引从0开始，可以进行截取，组合等。

tup1 = (\'physics\', \'chemistry\', 1997, 2000);tup2 = (1, 2, 3, 4, 5, 6, 7 );print \"tup1[0]: \", tup1[0]print \"tup2[1:5]: \", tup2[1:5]# 输出结果tup1[0]:  physicstup2[1:5]:  (2, 3, 4, 5)

2.2 修改元组

以下修改元组元素操作是非法的。
tup1[0] = 100

tup1 = (12, 34.56)tup2 = (\'abc\', \'xyz\')# 创建一个新的元组tup3 = tup1 + tup2print (tup3)#输出：(12, 34.56, \'abc\', \'xyz\')

2.3 删除元组

元组中的元素值是不允许删除的，但我们可以使用del语句来删除整个元组。

tup = (\'Google\', \'Runoob\', 1997, 2000)del tup

2.4 元组解包

元组解包指将元组当中的每一个元素都赋值给一个变量。

# 在对一个元祖解包的时候，变量的数量要和元祖中元素的数量保持一致# my_tuple = 10,20,30,40# a,b,c,d = my_tuple# 如果变量和元素不一致，也可以在变量前面加上一个 *。这样会获取元祖中剩余的元素# 以列表形式返回a,b,*c = my_tupleprint(\'a =\',a)print(\'b =\',b)print(\'c =\',c)# 输出结果a = 10b = 20c = [30, 40]

3. 元组的内置函数

Python元组包含了以下内置函数：

• cmp(tuple1, tuple2)
  比较两个元组元素。

返回值
如果比较的元素是同类型的,则比较其值,返回结果。
如果两个元素不是同一种类型,则检查它们是否是数字：
    如果是数字,执行必要的数字强制类型转换,然后比较。
    如果有一方的元素是数字,则另一方的元素\”大\”(数字是\”最小的\”)
    否则,通过类型名字的字母顺序进行比较。
如果有一个列表首先到达末尾,则另一个长一点的列表\”大\”。
如果我们用尽了两个列表的元素而且所> 有元素都是相等的,那么结果就是个平局,就是说返回一个 0。

• len(tuple)
  计算元组元素个数。
• max(tuple)
  返回元组中元素最大值。
• min(tuple)
  返回元组中元素最小值。
• tuple(seq)
  将列表转换为元组。

4. 元组运算符

• 计算元素个数
  表达式：len((1, 2, 3))
  结果：3

• 连接
  表达式：(1, 2, 3) + (4, 5, 6)
  结果：(1, 2, 3, 4, 5, 6)

• 复制
  表达式：(‘Hi!’,) * 4
  结果：(‘Hi!’, ‘Hi!’, ‘Hi!’, ‘Hi!’)

• 元素是否存在
  表达式：3 in (1, 2, 3)
  结果：True

• 迭代
  表达式：for x in (1, 2, 3): print (x,)
  结果：1 2 3

二、字典

1. 字典的基本介绍

字典属于⼀种新的数据结构称为映射(mapping)；

字典的作⽤和列表类似，都是⽤来存储对象的容器；
列表存储数据的性能好，但是查询数据的性能差，字典正好与之相反；

字典我们也称之为键值对(key-value)结构；
每个字典中都可以有多个键值对，⽽每⼀个键值对我们称其为⼀项(item)；

创建⼀个有数据的字典
语法 {key:value}
字典的值可以是任意对象
字典的键可以是任意的不可变对象(int str bool tuple…)
字典的键是不能重复的，如果出现重复的后⾯的会替换前⾯的

2. 字典的使用

2.1 创建字典

使用dict()函数来创建字典

d = dict(name=\'钢铁侠\',age=35,sex=\'男\')

dict()函数也可以将一个包含有双值子序列转换为字典

# 双值序列 序列中有2个值 [1,2] (\'b\',\'a\') \'ab\'# 子序列 如果序列中的元素，那么我们就称这个元素为子序列 [1,2,3]（No）[(1,2),(3,4)]d = dict([(\'name\',\'钢铁侠\'),(\'age\',35)])

2.2 访问字典中的值

可以根据键来获取字典当中的值
语法：d[key]

d = {\'name\':\'钢铁侠\',\'age\':38,\'sex\':\'男\'}print(d[\'age\'])

get(key,[default]) 该方法是用来根据键来获取字典当中的值；
如果字典当中没有这个Key值，会返回一个None；
也可以指定一个默认值。来作为第二个参数，这样获取不到Key值的时候就返回默认值。

print(d.get(\'age\'))print(d.get(\'hello\',\'这个key值不存在\'))

2.3 修改字典

修改字典
语法：d[key] = value

d = {\'name\':\'钢铁侠\',\'age\':38,\'sex\':\'男\'}# 修改字典中的key-valued[\'name\'] = \'葫芦娃\'# 向字典中添加 key-valued[\'phone\'] = \'123456789\'print(d)  # {\'name\':\'葫芦娃\',\'age\':38,\'sex\':\'男\'，\'phone\':\'123456789\'}

setdefault(key,[default]) 向字典中添加 key-value
如果这个key已经存在于字典当中，则返回key值，不会对字典有任何的影响
如果Key不存在 则向字典中添加这个key 并设置value

d = {\'name\':\'钢铁侠\',\'age\':38,\'sex\':\'男\'}result = d.setdefault(\'name\',\'葫芦娃\')result = d.setdefault(\'hello\',\'葫芦娃\')print(result)  # 葫芦娃print(d)  # {\'name\': \'钢铁侠\', \'age\': 38, \'sex\': \'男\', \'hello\': \'葫芦娃\'}

update() 将其他字典当中的key-value添加到当前字典当中

d1 = {\'a\':1,\'b\':2,\'c\':3}d2 = {\'d\':4,\'e\':5,\'f\':6}d1.update(d2)print(d1)  # {\'a\': 1, \'b\': 2, \'c\': 3, \'d\': 4, \'e\': 5, \'f\': 6}print(d2)  # {\'d\': 4, \'e\': 5, \'f\': 6}

2.4 删除字典元素

del 来删除字典中的 key-value

d1 = {\'a\': 1, \'b\': 2, \'c\': 3, \'d\': 4, \'e\': 5, \'f\': 6}del d1[\'a\']del d1[\'b\']print(d1)  # {\'c\': 3, \'d\': 4, \'e\': 5, \'f\': 6}

popitem() 随机删除一个键值对，一般都会删除最后一个；
它会将删除之后的键值对作为返回值返回，返回的是一个元祖；
元祖中有2个元素，第一个元素是删除的Key，第二个元素是删除的value。

d1={\'c\': 3, \'d\': 4, \'e\': 5, \'f\': 6}d1.popitem()result = d1.popitem()print(result)  # (\'e\', 5)

3. copy()浅复制

浅复制只会复制字典的本身，如果字典中还有个字典是不会被复制的；
用于对字典进行一个浅复制；
复制以后的对象，和原对象是独立的，修改一个不会影响另一个。

d = {\'a\':{\'name\':\'黑猫警长\',\'age\':18},\'b\':2,\'c\':3}d2 = d.copy()d[\'a\'] = 60# d2[\'a\'][\'name\'] = \'皮卡丘\'print(\'d = \',d,id(d))    # d =  {\'a\': 60, \'b\': 2, \'c\': 3} 2594264677616print(\'d2 =\',d2,id(d2))  # d2 = {\'a\': {\'name\': \'黑猫警长\', \'age\': 18}, \'b\': 2, \'c\': 3} 2594264677976

4. 遍历字典

d.keys() 该方法返回的是一个序列，保存的是字典中所有的键；
d.values() 该方法返回的是一个序列，保存的是字典中的值；
d.items() 该方法会返回字典中所有的项 ，它返回的也是一个序列，这个序列当中包含有双值子序列，双值就是字典中的key-value。

d = {\'name\':\'钢铁侠\',\'age\':38,\'sex\':\'男\'}for k in d.keys():print(d[k])  # dict_keys([\'name\', \'age\', \'sex\'])for v in d.values():print(v)# 钢铁侠# 38# 男

三、集合

1. 集合简介

可以使用{}来创建集合，通过set()来将序列和字典转换成集合
集合表现形式set 集合和列表非常相似，不同点：
    集合只能存储不可变对象
    集合中存储的对象是无序的
    集合不能出现重复元素

s = set(\'hello\')print(s,type(s))# 输出{\'o\', \'h\', \'e\', \'l\'} <class \'set\'>

• len() 获取集合中元素的数量

s = {\'a\',\'b\',1,2,3}print(len(s))

• add() 向集合中添加元素

s = {\'a\',\'b\',1,2,3}# add()这个方法是像集合中添加元素s.add(4)s.add(5)print(s)# {1, 2, 3, 4, 5, \'a\', \'b\'}

• update() 将一个集合中的元素添加到另一个集合当中

s = {\'a\',\'b\',1,2,3}s2 = set(\'hello\')s.update(s2)print(s)print(s2)# 输出{1, 2, 3, \'a\', \'e\', \'b\', \'l\', \'h\', \'o\'}{\'h\', \'e\', \'o\', \'l\'}

• pop() 随机删除集合中的一个元素，一般是删除最后一个元素

s = {\'a\',\'b\',1,2,3}r = s.pop()print(s)print(r)# 输出{2, 3, \'b\', \'a\'}1

• remove() 删除集合中指定的元素

s = {\'a\',\'b\',1,2,3}s.remove(\'a\')

• clear() 清空集合

s = {\'a\',\'b\',1,2,3}s.clear()print(s)# set()

2. 集合的运算

&  交集运算|  并集运算-  差集运算^  亦或集<= 检查一个集合是否是另一个集合的子集<  检查一个集合是否是另一个集合的真子集>= 检查一个集合是否是另一个集合的超集>  检查一个集合是否是另一个集合的真超集

s = {1,2,3,4,5}s2 = {3,4,5,6,7}# & 交集运算r = s & s2  # {3, 4, 5}# | 并集运算r = s | s2  # {1, 2, 3, 4, 5, 6, 7}# - 差集运算r = s - s2  # {1, 2}r = s2 - s  # {6, 7}# ^ 亦或集r = s2 ^ sprint(s,s2,r) # {1, 2, 3, 4, 5} {3, 4, 5, 6, 7} {1, 2, 6, 7}a = {1,2,3}b = {1,2,3,4,5}r = b <= aprint(r)  # False

总结

点击访问源图