python基础学习(七)：字典、元组、集合

1. 元组

元组（tuple）是 Python 中另一个重要的序列结构，和列表类似，元组也是由一系列按特定顺序排序的元素组成

1.1 元组基本介绍

• 表现形式：tuple
• 元组是不可变序列（一般当我们希望数据不改变时，使用元组，其他情况使用列表）

1.2 元组的使用

• 创建元组：使用（）创建

tup = ()
print(tup,type(tup))

() <class 'tuple'>

• 添加元组元素

tup = (1,2,3,4,5)

(1, 2, 3, 4, 5)

• 访问元组元素：通过索引访问

print(tup[2])

3

• 修改元组：元组作为不可变序列，无法修改，会报错

tup[2] = 8
# TypeError: 'tuple' object does not support item assignment

• 元组的形式：如果元组不是空的，它里面至少要有一个, ()可以省略

tup1 = 10,
tup2 = 1,2,3,4,5

(10,) 
(1, 2, 3, 4, 5)

• 元组的解包：将元组中的每一个元素赋值给一个变量

tup = 10,20,30,40
a,b,c,d = tup
print('a =',a)
print('b =',b)
print('c =',c)
print('d =',d

a = 10
b = 20
c = 30
d = 40

• 当变量的个数少于元组内元素的个数时，会报错

a,b = tup 
print('a =',a)
print('b =',b)

ValueError: too many values to unpack (expected 2)

• 解决方法：在其中一个变量前面➕ ，该变量返回的是一个列表， 可以➕在a、b、c三个变量的其中任意一个，不能给一个以上的变量➕
  • 在对元组进行解包时，变量的数量必须与元组的元素一一对应，如果出现不对应，可以在其中一个变量前面加上*，将获取到的元组中剩余的元素以列表返回

*a,b,c = tup
print('a =',a)
print('b =',b)
print('c =',c)

a = [10, 20]
b = 30
c = 40

---

2. 字典

Python 字典（dict）是一种无序的、可变的序列，它的元素以“键值对（key-value）”的形式存储

2.1 字典基本介绍

• 字典属于一种新的数据结构：映射，简单理解，它指的是元素之间相互对应的关系，即通过一个元素，可以唯一找到另一个元素
  
• 在字典中每一个元素都有一个唯一的名字，通过这个唯一的名字可以快速查找到指定的元素
  • 这个唯一的名字称为key，通过key可以快速查询value，即值
  • 字典也称为键值对（key-value）结构
  • 每个字典可以有多个键值对，而每个键值称其为一项（item）
• 语法：{key:value}
  • 字典的值可以为任意对象，字典的键是任意的不可变对象（int、str、tuple、bool…）
  • 字典的键是不能重复的，如果出现重复，后面的会替换前面的

d ={'name':'蜘蛛侠','age':'19','sex':'男','name':'超人'}
print(d)

{'name': '超人', 'age': '19', 'sex': '男'}

• 字典的表现形式：dict
• 创建字典

d = {}
print(d,type(d))

{} <class 'dict'>

• 字典的其他写法

d2 = {
    'name':'蜘蛛侠',
    'age':'19',
    'sex':'男'
}
print(d2)

{'name': '蜘蛛侠', 'age': '19', 'sex': '男'}

• 根据键获取值

d ={'name':'蜘蛛侠','age':'19','sex':'男','name':'超人'}
print(d['name'],d['age'],d['sex'])

超人 19 男

2.2 字典的使用

• 创建字典：除了{} 创建，还可以用dict()函数创建

d = dict(name='蜘蛛侠',age=19,sex='男')
print(d)

{'name': '蜘蛛侠', 'age': 19, 'sex': '男'} 

• len()：获取字典中键值对的个数

d = dict(name='蜘蛛侠',age=19,sex='男')
print(len(d))

3

• in 或者 not in：检查字典中是否包含指定的键

print('name' in d)
print('蜘蛛侠' not in d)

True
True

• 根据键获取字典中的值
  • 语法：dict[key] ，key要加引号，不然会被当作变量处理

d = dict(name='蜘蛛侠',age=19,sex='男')
print(d['name'])

19

• 不加引号程序会把它当作一个变量名而报错

print(d[age])
# NameError: name 'age' is not defined

• get()：
  • 语法：dictname.get(key[,default])
  • 该方法根据字典中的key来获取值，dictname 表示字典变量的名字，key 表示指定的键，default 用于指定要查询的键不存在时，此方法返回的默认值，如果不手动指定，会返回 None

print(d.get('name1'))

None

print(d.get('name1','key值不存在'))

key值不存在

• 修改存在的key值

d['name'] = '超人'
print(d)

{'name': '超人', 'age': 19, 'sex': '男'}

• 修改不存在的key值，会直接向字典中添加key-value

d['phone'] = '123456'
print(d)

{'name': '蜘蛛侠', 'age': 19, 'sex': '男', 'phone': '123456789'}

• setdefault()：
• 语法：dictname.setdefault(key,[,default])
• 如果key存在，返回key的值，不会对字典做任何操作；如果key不存在，则向字典中添加这个key，并设定值

d.setdefault('name','蚁人')
print(d)

{'name': '蜘蛛侠', 'age': 19, 'sex': '男'}

d.setdefault('phone','123456')
print(d)

{'name': '蜘蛛侠', 'age': 19, 'sex': '男', 'phone': '123456'}

• update()：将其他字典的key-value添加到当前字典中，如果有重复的key，后面的会替换前面的

d1 = {'a':'python','b':'java'}
d2 = {'c':'php','d':'c++','a':'c'}
d1.update(d2)
print(d1)

{'a': 'c', 'b': 'java', 'c': 'php', 'd': 'c++'}

• del()：删除字典中的key-value

del d1['a']
print(d1)

{'b': 'java'}

• popitem()：随机删除字典中的一个key-value，一般是最后一个，并且返回删除的key-value，以元组形式返回

result = d2.popitem()
print(result)
print(d2)

('a', 'c')
{'c': 'php', 'd': 'c++'}

• pop(key[,default])：根据key删除字典的key-value，并且会将删除的value返回，如果key值不存在，避免程序报错，可以返回默认值

result = d2.pop('d')
print(result)
print(d2)

c++
{'c': 'php', 'a': 'c'}

result = d2.pop('x','这个key值不存在')
print(result)
print(d2)

这个key值不存在
{'c': 'php', 'd': 'c++', 'a': 'c'}

2.3 copy()

• 复制与浅复制
• 复制：复制以后的对象是独立的，修改其中一个不会影响另一个

d1 = {'c':'php','d':'c++','a':'c'}
d2 = d1.copy()
d1['c'] = 'python'
print('d1=',d1,id(d1))
print('d2=',d2,id(d2))

d1= {'c': 'python', 'd': 'c++', 'a': 'c'} 4445436224
d2= {'c': 'php', 'd': 'c++', 'a': 'c'} 4445436288

• 浅复制：浅复制只是复制字典本身，如果字典中还有字典，是不会被复制，这个值也可以是其他可变对象，这和可变对象也不会被复制

d = {'c':'php','d':'c++','a':{'name':'超人','age':'19'}}
d1 = d.copy()
d['a']['name'] = '蚁人'
print('d=',d,id(d))
print('d1=',d1,id(d1))

d= {'c': 'php', 'd': 'c++', 'a': {'name': '蚁人', 'age': '19'}} 4528683712
d1= {'c': 'php', 'd': 'c++', 'a': {'name': '蚁人', 'age': '19'}} 4528729472

2.4 遍历字典

• keys()：返回字典中所有的key

d = {'c': 'python', 'd': 'c++', 'a': 'c'}
print(d.keys())
for k in d.keys():
    print(d[k])

dict_keys(['c', 'd', 'a'])
python
c++
c

• values()：返回字典中所有key对应的value

print(d.values())
for v in d.values():
    print(v)

dict_values(['python', 'c++', 'c'])
python
c++
c

• items()：返回字典中所有的key-value

print(d.items())
for k,v in d.items():
    print(k,'=',v)

dict_items([('c', 'python'), ('d', 'c++'), ('a', 'c')])
c = python
d = c++
a = c

---

3. 集合

Python 中的集合，和数学中的集合概念一样，用来保存不重复的元素，即集合中的元素都是唯一的，互不相同

3.1 集合的基本介绍

• 与列表非常相似，它们之间的不同点：
  • 集合只能存储不可变对象
  • 集合中存储的对象是无序的
  • 集合不能出现重复对象

3.2 集合的使用

• 创建集合

a = {1,2,3}
print(a,type(a))

{1, 2, 3} <class 'set'>

• set()方法创建集合：set() 函数为 Python 的内置函数，其功能是将字符串、列表、元组、range 对象等可迭代对象转换成集合

a = set()
a1 = set('python')
a2 = set([1,2,3])
a3 = set({'a':1,'b':2,'c':3})
a4 = set((1,2,3))
print(a,type(a))
print(a1,type(a1))
print(a2,type(a2))
print(a3,type(a3))
print(a4,type(a4))

set() <class 'set'>
{'o', 'y', 'p', 'h', 't', 'n'} <class 'set'>
{1, 2, 3} <class 'set'>
{'c', 'b', 'a'} <class 'set'>
{1, 2, 3} <class 'set'>

• 集合的无序与不可重复性

a = {6,5,4,3,2,1,1,1,}
print(a,type(a))

{1, 2, 3, 4, 5, 6} <class 'set'>

• 集合不能通过索引取值

a = {'a','b',1,2,3}
print(a[0])

TypeError: 'set' object is not subscriptable

• 可以将集合转化为列表进行索引取值

a = {'a','b',1,2,3}
s = list(a)
print(s[2])

3

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

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

5

• add()：向集合中添加元素，只能是数字、字符串、元组或者布尔类型（True 和 False）值，不能添加列表、字典、集合这类可变的数据，否则 Python 解释器会报 TypeError 错误

s.add(('python'))
print(s)

{1, 2, 3, 'a', 'b', 'python'}

s.add(['java','php'])
print(s)

TypeError: unhashable type: 'list'

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

s1 = {4,5,6}
s.update(s1)
print(s)

{1, 2, 3, 4, 5, 6, 'a', 'b'}

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

result = s.pop()
print(result)
print(s)

b
{1, 2, 'a', 3}

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

s.remove('a')
print(s)

{1, 2, 3, 'b'}

• clear()：清空集合

s.clear()
print(s)

set()

3.3 集合的运算

• &：交集运算

s1 = {1,2,3,4,5}
s2 = {4,5,6,7,8}
print(s1 & s2)

{4,5}

• |：并集运算

print(s1 | s2)

{1,2,3,4,5,6,7,8}

• -：差集运算

print(s1 - s2)

{1,2,3}

• ^：亦或集运算，两个集合不相交的部分

print(s1 ^ s2)

{1,2,3,6,7,8}

• 字集、真字集、超集、真超集

<=：检查一个集合是否是另一个的字集
>=：检查一个集合是否是另一个的超集
<：检查一个集合是否是另一个的真字集
>：检查一个集合是否是另一个的真超集

a = {1,2,3}
b = {1,2,3,4,5}
print(a < b)

True

• 总结：如果b集合含有a集合所有的元素，并且b集合还有a集合没有的元素，那么b集合就是a集合的真超集，即a集合是b集合的真字集