Python基础课--第八节 元组&字典&集合

1 元组简介

1.1 元组基本介绍

• 元组表现形式tuple
• 元组是⼀个不可变序列(⼀般当我们希望数据不改变时，我们使⽤元组，其他情况下基本都⽤列表)

1.2 用()创建

my_tuple = (1,2,3,4,5)
print(my_tuple[3])
结果
4

my_tuple = 10
print(my_tuple,type(my_tuple))
结果
10 <class 'int'>

1.3 元组不是空元组⾄少有⼀个 逗号(,) 当元组不是空元组时括号可以省略

my_tuple = 10,20,30,40

print(my_tuple,type(my_tuple))

结果
(10, 20, 30, 40) <class 'tuple'>

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

# 元组解包--将元组当中的每⼀个元素都赋值给⼀个变量
my_tuple = 10,20,30,40
a,b,c,d = my_tuple
print(a,b,c,d)
结果
10 20 30 40

a = 6
b = 8
b,a = a,b
print('a =',a,'b=',b)
结果
a = 8 b= 6

在对一个元组进行解包时，变量的数量要和元组中元素保持一致当变量和元组当中的数量不一致时，我们可以在变量前面添加一个*，变量将会获取元组中剩余的元素

# 只想取前几个
my_tuple = 10,20,30,40
a,b,*c = my_tuple
print(a,b)
print(*c)        # *c是30 40
print(c)        # c是[30, 40]

a,*b,c  = 10,20,30,40
print('a =',a,'b=',b,'c=',c) 
结果
a = 10 b= [20, 30] c= 40

a,*b,c  = 'python and java'
print('a =',a,'\n''b=',b,'\n''c=',c)
结果
a = p 
b= ['y', 't', 'h', 'o', 'n', ' ', 'a', 'n', 'd', ' ', 'j', 'a', 'v'] 
c= a

2 可变对象

• Python中，数值类型（int和float）、字符串str、元组tuple都是不可变类型。⽽列表list、字典dict、集合set是可变类型
• 可变对象中都保存了三个数据
  id(标识)
  type(类型)
  value(值)
• 两个例子对比

1. 通过变量修改对象里面的值，这种操作不会改变变量指向的对象

a = [1, 2, 3]
print('修改前:', a, id(a))
a[0] = 10
print('修改后:', a, id(a))
结果
修改前: [1, 2, 3] 2503931675208
修改后: [10, 2, 3] 2503931675208

2. 给变量重新赋值，会改变变量所指向的对象

a = [1, 2, 3]
print('修改前:', a, id(a))
# 给变量重新赋值，会改变变量所指向的对象
a = [4, 5, 6]
print('修改后:', a, id(a))

结果
修改前: [1, 2, 3] 2459146797640
修改后: [4, 5, 6] 2459146822280

3. 这里的a和b指向同一个对象

a = [1, 2, 3]
print('修改前:', a, id(a))
b = a
b[0] = 10
print('修改后:', a, id(a))
print('修改后:', b, id(b))

结果
修改前: [1, 2, 3] 2149122589256
修改后: [10, 2, 3] 2149122589256
修改后: [10, 2, 3] 2149122589256

• ==和is !=和is not
  == 和 != 比较的是对象的值是否相等
  is 和 is not 比较的是对象的id是否相等

a = [1, 2, 3]
print('修改前:', a, id(a))
b = [1, 2, 3]

print('修改后:', b, id(b))

print(a is b)
print(a == b)

结果
修改前: [1, 2, 3] 3155030327816
修改后: [1, 2, 3] 3155030352456
False
True

3 字典

3.1 字典的基本介绍

• 字典属于⼀种新的数据结构称为映射(mapping)
• 字典的作⽤和列表类似，都是⽤来存储对象的容器
• 列表存储数据的性能好，但是查询数据的性能差，字典正好与之相反
• 在字典中每⼀个元素都有唯⼀的名字，通过这个唯⼀的名字可以找到指定的元素
• 这个唯⼀的名字我们称之为key 通过key可以快速查询value 也可以称之为值
• 字典我们也称之为键值对(key-value)结构
• 每个字典中都可以有多个键值对，⽽每⼀个键值对我们称其为⼀项(item)
• 创建⼀个有数据的字典 语法 {key:value}
• 字典的值可以是任意对象 字典的键可以是任意的不可变对象(int str bool tuple…)
• 字典的键是不能重复的，如果出现重复的后⾯的会替换前⾯的

# 语法 {key:value,key:value…}
d = {'name':'葫芦娃','age':7,'gender':'男','name':'钢铁侠'}
print(d,type(d))
结果
{'name': '钢铁侠', 'age': 7, 'gender': '男'} <class 'dict'>

3.2 字典的使用

d = dict(name='葫芦娃',age=7,gender='男')
print(d,type(d))
结果
{'name': '葫芦娃', 'age': 7, 'gender': '男'} <class 'dict'>

• dict()这个函数可以将一个包含有双值子序列转换成字典
• 双值序列：序列中只有2个值 [3,4] ， (‘x’,1) ，‘xy’
  子序列：如果序列当中的元素也是序列，那么我们就称之为这个元素为子序列[(1,2),(3,4)]----(1,2)是子序列

d = dict([('name','葫芦娃'),('age',7),'ab'])
print(d,type(d))
结果
{'name': '葫芦娃', 'age': 7, 'a': 'b'} <class 'dict'>

• len() 长度可以获取字典当中键值对的个数
  in 和 not in 检查字典当中是否包含、不包含指定的键
  d[key] 获取字典里面的值–如果是变量就不加引号，如果是字符串就加引号
  get(key[,default]) 根据键来获取字典当中的值，获取的键不存在，会返回None

d = dict([('name','葫芦娃'),('age',7),'ab'])
# print(d,type(d))
print(len(d))          #获取字典当中键值对的个数
print('name' in d) # 检查字典当中是否包含、不包含指定的键
print(d['age']) # 获取字典中的值，根据键key来获取，，，如果是变量就不加引号，如果是字符串就加引号

print(d.get('a')) # get(key[,default]) 根据键来获取字典当中的值，获取的键不存在，会返回None
结果
3
True
7
b

d = dict([('name','葫芦娃'),('age',7),'ab'])
# print(d,type(d))
print(len(d))          #获取字典当中键值对的个数
print('name' in d) # 检查字典当中是否包含、不包含指定的键
print(d['age']) # 获取字典中的值，根据键key来获取，，，如果是变量就不加引号，如果是字符串就加引号

# 也可以指定一个默认值来作为第二个参数，这样获取不到值得时候会返回默认值
print(d.get('b','该值不存在')) # get(key[,default]) 根据键来获取字典当中的值，获取的键不存在，会返回None
结果
3
True
7
该值不存在

3.3 修改字典

• 修改字典 d[key] = value 如果存在则覆盖，不存在则添加

d = {'name':'葫芦娃','age':7,'gender':'男'}
d['name'] = '钢铁侠' # 存在覆盖
d['phone'] = 'abc'  # 不存在则添加
print(d)
结果
{'name': '钢铁侠', 'age': 7, 'gender': '男', 'phone': 'abc'}

• d.setdefault(key[,default]) 可以用来向字典当中添加键值对
  如果key已经存在字典当中，则返回key的值，不会对字典做任何操作

d = {'name':'葫芦娃','age':7,'gender':'男'}
r = d.setdefault('name','大哥')
s = d.setdefault('Stonebridge','南大人')
print(r)
print(d) 

结果
葫芦娃
{'name': '葫芦娃', 'age': 7, 'gender': '男', 'Stonebridge': '南大人'}

如果key不存在，则向字典当中添加这个key，并设置value

d = {'name':'葫芦娃','age':7,'gender':'男'}
r = d.setdefault('name','大哥')
s = d.setdefault('Stonebridge','南大人')
print(s)
print(d)

结果
南大人
{'name': '葫芦娃', 'age': 7, 'gender': '男', 'Stonebridge': '南大人'}

• update() 将其他的字典当中键值对添加到当中的字典当中
  如果存在相同key值，后面会覆盖原来key的value

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

结果
{'a': 8, 'b': 2, 'c': 3, 'd': 4, 'e': 5, 'f': 6}

• del 删除字典中的key-value

d = {'a':1,'b':2,'c':3}
del d['a']

print(d)
结果
{'b': 2, 'c': 3}

• popitem() 删除字典最后的⼀个key-value 这个⽅法是有返回值的。
  删除之后它会将删除的key-value作为返回值返回

d = {'a':1,'b':2,'c':3}
r = d.popitem()
print(r)
print(d)
结果

('c', 3)
{'a': 1, 'b': 2}

• pop(key[,default]) 根据key删除字典当中的键值对key-value，返回的是删除的value值，

# pop(key[,default])

d = {'a':1,'b':2,'c':3}
r = d.pop('b')
print(r)
print(d)
结果
2
{'a': 1, 'c': 3}

如果删除不存在的Key,会抛出异常，
如果指定了默认值，删除不存在的key值的时候，就会返回默认值

d = {'a':1,'b':2,'c':3}
r = d.pop('w','没有这个key值')
print(r)
print(d)
结果
没有这个key值
{'a': 1, 'b': 2, 'c': 3}

3.4 浅复制

• copy() ⽅法⽤来对字典进⾏潜复制

d = {'a':1,'b':2,'c':3}
d2 = d.copy()
# d['a'] = 30
print('d =',d,id(d))
print('d2 =',d2,id(d2))
结果
d = {'a': 1, 'b': 2, 'c': 3} 2838481072200
d2 = {'a': 1, 'b': 2, 'c': 3} 2838481072272

• 注意:潜复制只会简单复制字典本身，如果字典中还有个字典是不会进⾏复制的—如果值是可变对象，这个可变对象不会被复制

d = {'a':{'name':'葫芦娃','age':7},'b':2,'c':3}
d2 = d.copy()
d2['a']['name'] = '黑猫警长' # 字典中的字典
print('d =',d,id(d))
print('d2 =',d2,id(d2))
结果
d = {'a': {'name': '黑猫警长', 'age': 7}, 'b': 2, 'c': 3} 2292032532624
d2 = {'a': {'name': '黑猫警长', 'age': 7}, 'b': 2, 'c': 3} 2292035030400

• 复制后的对象和原对象是独立的，修改一个不会影响另一个

d = {'a':1,'b':2,'c':3}
d2 = d.copy()
# 复制后的对象和原对象是独立的，修改一个不会影响另一个
d2['a'] = 30
print('d =',d,id(d))
print('d2 =',d2,id(d2))
结果
d = {'a': 1, 'b': 2, 'c': 3} 1954699472968
d2 = {'a': 30, 'b': 2, 'c': 3} 1954699473040

4 遍历字典

• keys() 该⽅法返回字典所有的key

d = {'name':'葫芦娃','age':7,'gender':'男'}

print(d.keys())
print(d['age'])
for k in d.keys():
    print(d[k])
结果
dict_keys(['name', 'age', 'gender'])
7
葫芦娃
7
男

• values() 该⽅法返回⼀个序列 序列中保存有字典的值

d = {'name':'葫芦娃','age':7,'gender':'男'}
for v in d.values():
    print(v)
结果
葫芦娃
7
男

• items() 该⽅法会返回字典中所有的项 它返回⼀个序列，序列中包含有双值⼦序列 双值分别是 字典中的key和value

d = {'name':'葫芦娃','age':7,'gender':'男'}
print(d.items())
结果
dict_items([('name', '葫芦娃'), ('age', 7), ('gender', '男')])

d = {'name':'葫芦娃','age':7,'gender':'男'}
# print(d.items())

for k,v in d.items():

    print(k,v)
    print(v)
结果
name 葫芦娃
葫芦娃
age 7
7
gender 男
男

5 集合

5.1 集合简介

• 集合表现形式set 集合和列表⾮常相似
• 不同点
  集合只能存储不可变对象 列表是可变对象
  集合中存储的对象是⽆序的
  集合不能出现重复元素

5.2 集合的创建

• 使⽤{}来创建集合.

s = {20,30,(1,2,3),4,'python'}
s1 = {}
print(s,type(s))
print(s1,type(s1))
结果
{4, 'python', (1, 2, 3), 20, 30} <class 'set'>
{} <class 'dict'>

• 可以通过set()来将序列和字典转换成集合

s = set([1,1,2,5,9,8,6]) # 列表
s1 = set('python')       # 字符串

# 使用set函数将字典转化为集合时 ---结果只会包含字典的key
s2 = set({'a':1,'b':2})
print(s,type(s))
print(s1,type(s1))
print(s2,type(s2))

结果
{1, 2, 5, 6, 8, 9} <class 'set'>
{'t', 'y', 'n', 'o', 'p', 'h'} <class 'set'>
{'a', 'b'} <class 'set'>

• 集合不可以/不支持通过索引寻找元素

# 创建一个集合
s = {'a', 'b',1,2,3}

# 集合不可以/不支持通过索引寻找元素
# 如果想找某一位置的元素，可以转化为列表
print(list(s))
print(list(s)[3])
结果---==较为随机==
[1, 2, 3, 'b', 'a']
b

5.3 集合的使用

• in 和 not in 来检查集合中的元素，结果会返回一个bool值

s = {'a', 'b',1,2,3}
print('b' in s) 
结果
True

• len() 使⽤len()来获取集合中元素的数量
• add()像集合中添加元素

s = {'a', 'b',1,2,3}
print(len(s))
s.add(20)
s.add(50)
print(s)
结果
5
{1, 2, 3, 'a', 'b', 50, 20}

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

# update 将一个集合中 元素添加到当前集合中
s = {'a', 'b',1,2,3}
s1 = set('hello')
s.update(s1)
print(s)
结果
{'e', 1, 2, 3, 'a', 'o', 'l', 'h', 'b'}

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

s = {'e', 1, 2, 3, 'a', 'o', 'l', 'h', 'b'}
print(s)
result = s.pop()
print(result)
print(s)
结果
{1, 2, 3, 'b', 'h', 'a', 'o', 'l', 'e'}
1
{2, 3, 'b', 'h', 'a', 'o', 'l', 'e'}

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

s = {'e', 1, 2, 3, 'a', 'o', 'l', 'h', 'b'}
print(s)
s.remove('a')
print(s)
结果
{1, 2, 3, 'b', 'h', 'l', 'o', 'e', 'a'}
{1, 2, 3, 'b', 'h', 'l', 'o', 'e'}

• clear() 清空集合

s = {'e', 1, 2, 3, 'a', 'o', 'l', 'h', 'b'}
print(s)
s.clear()
print(s)
结果
{1, 2, 3, 'h', 'a', 'b', 'l', 'e', 'o'}
set()

5.2 集合的运算

• & 交集运算.
• | 并集运算
• -差集运算
• ^ 亦或集

s1 = {1, 2, 3, 4, 5}
s2 = {3, 4, 5, 6, 7}
r1 = s1 & s2 #  & 交集运算.
r2 = s1 | s2 #  | 并集运算
r3 = s1 - s2 #  - 差集运算
r4 = s1 ^ s2 #  ^ 亦或集
print(r1)
print(r2)
print(r3)
print(r4)
结果
{3, 4, 5}
{1, 2, 3, 4, 5, 6, 7}
{1, 2}
{1, 2, 6, 7}

• <= 检查⼀个集合是否是另⼀个集合的⼦集
• < 检查⼀个集合是否是另⼀个集合的真⼦集
  如果超集b包含a子集中的所以元素，并且b中还有a中没有的元素，b是a的真超集
• 检查⼀个集合是否是另⼀个集合的超集>=
• 检查⼀个集合是否是另⼀个集合的真超集>

s1 = {1, 2, 3, 4, 5}
s2 = {3, 4, 5}
print(s2 <= s1) # 检查一个集合是否是另一个集合的子集 <=  s2是s1的子集，s1是s2的超集
print(s2 < s1) # 检查一个集合是否是另一个集合的真子集 <
print(s2 >= s1) # 检查一个集合是否是另一个集合的超集 >=
print(s1 > s2) # 检查一个集合是否是另一个集合的真超集 >
结果
True
True
False
True