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

一、元组

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]:  physics
tup2[1:5]:  (2, 3, 4, 5)

2.2 修改元组

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

tup1 = (12, 34.56)
tup2 = ('abc', 'xyz')

# 创建一个新的元组
tup3 = tup1 + tup2
print (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_tuple
print('a =',a)
print('b =',b)
print('c =',c)

# 输出结果
a = 10
b = 20
c = [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-value
d['name'] = '葫芦娃' 

# 向字典中添加 key-value
d['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} 2594264677616
print('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 ^ s 
print(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 <= a
print(r)  # False

---

总结

点击访问源图