Python基础知识七 元组&字典&集合

一、元组

1、元组的概念

• 元组 tuple，是一个不可变序列
• 一般情况下如果不希望数据改变的时候就用元组，其余情况都用列表

my_tuple = (1,2,3,4,5)
print(my_tuple,type(my_tuple))    # (1, 2, 3, 4, 5) <class 'tuple'>
my_tuple[3] = 8    # TypeError: 'tuple' object does not support item assignment

• 当元组中只有一个元素时，元素后面应该要加一个逗号，这样才能成为元组。

a_tuple = (1)
print(a_tuple,type(a_tuple))    # 1 <class 'int'>

a_tuple = (1,)
print(a_tuple,type(a_tuple))    # (1,) <class 'tuple'>

2、元组的解包

• 元组的解包指将元组当中的每一个元素都赋值给一个变量。
• 在对一个元祖解包的时候，变量的数量要和元组中元素的数量保持一致。
• 如果变量的数量和元素的数量不一致，也可以在变量前面加上一个 星号*。这样会获取元组中剩余的元素，并以列表的形式返回。
• 任何可迭代对象都支持解包，可迭代对象包括元组、列表、字典、集合、字符串、生成器等。

my_tuple = 1,2,3,4,5
print(my_tuple, type(my_tuple))    # (1, 2, 3, 4, 5) <class 'tuple'>

a,b,*c = my_tuple
print('a =',a)    # a = 1
print('b =',b)    # b = 2
print('c =',c)    # c = [3, 4, 5]

a,*b,c = my_tuple
print('a =',a)    # a = 1
print('b =',b)    # b = [2, 3, 4]
print('c =',c)    # c = 5

*a,b,c = my_tuple
print('a =',a)    # a = [1, 2, 3]
print('b =',b)    # b = 4
print('c =',c)    # c = 5

*a,*b,c = my_tuple    # SyntaxError: two starred expressions in assignment
print('a =',a)
print('b =',b)
print('c =',c)

a,b,*c = 'hello python'
print('a =',a)    # a = h
print('b =',b)    # b = e
print('c =',c)    # c = ['l', 'l', 'o', ' ', 'p', 'y', 't', 'h', 'o', 'n']

a,b,*c = [1,2,3,4,5,6]
print('a =',a)    # a = 1
print('b =',b)    # b = 2
print('c =',c)    # c = [3, 4, 5, 6]

二、字典

1、字典的概念

• 字典 dict，映射（mapping）类型的数据结构。
• 字典的作用其实和列表类似，是用来存储对象的容器。
• 列表存储数据的性能非常好，但是查询数据的性能很差。而字典正好相反。
• 在字典当中每一个元素都有唯一的一个名字，通过这个名字可以快速查询到指定的元素。
• 这个唯一的名字我们一般称之为键 key，通过 key 我们可以查询到 value 值。
• 所以字典我们也称之为 键值对(key-value)。
• 每个字典当中可以有多个键值对，每一个键值对我们可以称之为一项（item）。
• 字典中的键是不能重复的，如果重复后面的会替换前面的。

2、语法

• 语法: {key:value,key:value…}

d = {'name':'钢铁侠','age':38,'sex':'男'}
# 需要根据键来获取值
print(d['name'],d['age'],d['sex'])    # 钢铁侠 38 男

3、字典的使用

3.1 创建字典

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

d = dict(name='钢铁侠',age=35,sex='男')
print(d,type(d))    # {'name': '钢铁侠', 'age': 35, 'sex': '男'} <class 'dict'>

• dict()函数也可以将一个包含有双值子序列转换为字典
  • 双值序列：序列中有2个值。例如 [1,2]、(‘b’,‘a’)、‘ab’
  • 子序列：如果序列中的元素也是序列，那么我们就称这个元素为子序列。例如 [(1,2),(3,4)]

d = dict([('name','钢铁侠'),('age',35)])
print(d,type(d))    # {'name': '钢铁侠', 'age': 35} <class 'dict'>

3.2 len()

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

d = {'name':'钢铁侠','age':38,'sex':'男'}
print(len(d))    # 3

3.3 in、not in

• in 检查字典中是否包含指定的键，返回True / False
• not in 检查字典中是否不包含指定的键

d = {'name':'钢铁侠','age':38,'sex':'男'}
print('name' not in d)    # False

3.4 获取字典中的值

3.4.1 根据键获取字典中的值

• 语法：d[key]

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

3.4.2 用get方法获取字典中的值

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

d = {'name':'钢铁侠','age':38,'sex':'男'}
print(d.get('age'))    # 38
print(d.get('job'))    # None
print(d.get('birthday','这个key值不存在'))    # 这个key值不存在

3.5 修改字典

3.5.1 d[key] = value

• 修改字典中的key-value

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

• 向字典中添加key-value

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

3.5.2 setdefault(key,[default])

• 向字典中添加 key-value
• 如果这个key已经存在于字典当中，则返回key值，不会对字典有任何的影响；
• 如果Key不存在，则向字典中添加这个key，并设置value。

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

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

3.5.3 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}

3.6 删除

3.6.1 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}

3.6.2 popitem( )

• 随机删除一个键值对，一般都会删除最后一个
• 它会将删除之后的键值对作为返回值返回。返回的是一个元组， 元组中有2个元素：第一个元素是删除的key，第二个元素是删除的value。

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

3.6.3 pop(key,[default])

• 根据key来删除 key-value

d1 = {'c': 3, 'd': 4, 'e': 5}
result = d1.pop('b','这个key值不存在')
print(result)    # 这个key值不存在
print(d1)    # {'c': 3, 'd': 4, 'e': 5}
result = d1.pop('c')
print(result)    # 3
print(d1)    # {'d': 4, 'e': 5}

3.6.4 clear( )

• 清空字典

d1 = {'c': 3, 'd': 4, 'e': 5}
d1.clear()
print(d1)    # {}

3.7 copy( )

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

d = {'a':{'name':'黑猫警长','age':18},'b':2,'c':3}
d1 = d
print('d =',d,id(d))  # d = {'a': {'name': '黑猫警长', 'age': 18}, 'b': 2, 'c': 3} 3039239036648
print('d1 =',d1,id(d1))  # d1 = {'a': {'name': '黑猫警长', 'age': 18}, 'b': 2, 'c': 3} 3039239036648

d1['b'] = 20
print('d =',d,id(d))  # d = {'a': {'name': '黑猫警长', 'age': 18}, 'b': 20, 'c': 3} 3039239036648
print('d1 =',d1,id(d1))  # d1 = {'a': {'name': '黑猫警长', 'age': 18}, 'b': 20, 'c': 3} 3039239036648

d1['a']['name'] = '皮卡丘'
print('d =',d,id(d))  # d = {'a': {'name': '皮卡丘', 'age': 18}, 'b': 20, 'c': 3} 3039239036648
print('d1 =',d1,id(d1))  # d1 = {'a': {'name': '皮卡丘', 'age': 18}, 'b': 20, 'c': 3} 3039239036648

d = {'a':{'name':'黑猫警长','age':18},'b':2,'c':3}
d2 = d.copy()
print('d =',d,id(d))  # d = {'a': {'name': '黑猫警长', 'age': 18}, 'b': 2, 'c': 3} 2039041318632
print('d2 =',d2,id(d2))  # d2 = {'a': {'name': '黑猫警长', 'age': 18}, 'b': 2, 'c': 3} 2039041347728

d2['b'] = 20
print('d =',d,id(d))  # d = {'a': {'name': '黑猫警长', 'age': 18}, 'b': 2, 'c': 3} 2039041318632
print('d2 =',d2,id(d2))  # d2 = {'a': {'name': '黑猫警长', 'age': 18}, 'b': 20, 'c': 3} 2039041347728

d2['a']['name'] = '皮卡丘'
print('d =',d,id(d))  # d = {'a': {'name': '皮卡丘', 'age': 18}, 'b': 2, 'c': 3} 2039041318632
print('d2 =',d2,id(d2))  # d2 = {'a': {'name': '皮卡丘', 'age': 18}, 'b': 20, 'c': 3} 2039041347728
# 修改d2中‘a’对应的字典，d中的字典也变了，说明字典{'name': '皮卡丘', 'age': 18}没有被复制。

4、遍历字典

4.1 keys( )

• 该方法返回的是一个序列，保存的是字典中所有的键。

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

4.2 values( )

• 该方法返回的是一个序列，保存的是字典中所有的值。

d = {'name':'钢铁侠','age':38,'sex':'男'}
print(d.values())    # dict_values(['钢铁侠', 38, '男'])
list_values = []
for k in d.values():
    list_values.append(k)
print(list_values)    # ['钢铁侠', 38, '男']

4.3 items( )

• 该方法返回的是一个序列，保存的是字典中所有的项。
• 这个序列当中包含有双值子序列，双值就是字典中的key-value。

d = {'name':'钢铁侠','age':38,'sex':'男'}
print(d.items())
for k,v in d.items():
    print(k,'=',v)
# 运行结果：
# dict_items([('name', '钢铁侠'), ('age', 38), ('sex', '男')])
# name = 钢铁侠
# age = 38
# sex = 男

三、集合

1、集合的概念

集合 set 和列表非常相似，但也有不同点：

• 1 集合中只能存储不可变对象
• 2 集合中存储的对象是无序的
• 3 集合中不能出现重复的元素

# 集合中只能存储不可变对象
s = {[1,2,3],[4,5,6]}    # TypeError: unhashable type: 'list'
print(s,type(s))

# 集合中存储的对象是无序的
s = {'a','b',1,2,3}
print(s[0])    # TypeError: 'set' object does not support indexing

# 集合中不能出现重复的元素
s = {2,3,1,4,2,2,3,1}
print(s,type(s))    # {1, 2, 3, 4} <class 'set'>

s = {}
print(s,type(s))    # {} <class 'dict'>

s = {1,2,3}
print(s,type(s))    # {1, 2, 3} <class 'set'>

# set() 可以将序列和字典转换为集合
s = set()
print(s,type(s))    # set() <class 'set'>

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

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

# 使用set()函数将字典转换为集合的时候，只会包含字典中的键
s = set({'a':1,'b':2,'c':3})
print(s,type(s))    # {'a', 'c', 'b'} <class 'set'>

s = {'a','b',1,2,3}
print(s,type(s))    # {1, 2, 3, 'b', 'a'} <class 'set'>
a = list(s)
print(a,type(a))    # [1, 2, 3, 'b', 'a'] <class 'list'>

2、集合的使用

2.1 in 和 not in

s = {'a','b',1,2,3}
print('a' in s)    # True
print('a' not in s)    # False

2.2 len( )

• 获取集合的长度（即集合内元素的个数）

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

2.3 add( )

• 向集合中添加元素

s = {'a','b',1,2,3}
s.add(4)
print(s)    # {1, 2, 3, 4, 'a', 'b'}

2.4 update( )

• 将一个集合中的元素添加到另一个集合中

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

2.5 pop( )

• 删除集合中的一个元素

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

2.6 remove( )

• 删除集合中指定的元素

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

2.7 clear( )

• 清空集合中的元素

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

3、集合的运算

3.1 交集运算 &

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

3.2 并集运算 |

s1 = {1,2,3,4,5}
s2 = {3,4,5,6,7}
r = s1 | s2
print(r)    # {1, 2, 3, 4, 5, 6, 7}

3.3 差集运算 -

s1 = {1,2,3,4,5}
s2 = {3,4,5,6,7}
r1 = s1 - s2
print(r1)    # {1, 2}
r2 = s2 - s1
print(r2)    # {6, 7}

3.4 异或集运算 ^

• 集合里面不相交的部分

s1 = {1,2,3,4,5}
s2 = {3,4,5,6,7}
r = s1 ^ s2
print(r)    # {1, 2, 6, 7}

3.5 比较运算

• 返回的是布尔类型
• <= 检查一个集合是否是另一个集合的子集
• < 检查一个集合是否是另一个集合的真子集
• >= 检查一个集合是否是另一个集合的超集
• > 检查一个集合是否是另一个集合的真超集

a = {1,2,3}
b = {1,2,3,4,5}
c = {1,2,3}
r1 = a <= b
print(r1)    # True
r2 = a < b
print(r2)    # True
r3 = a < c
print(r3)    # False

四、可变对象

• 每个对象都保存了三个数据：
  • 1.id(标识)
  • 2.type(类型)
  • 3.value(值)
• a = [1,2,3] 列表就是一个可变对象
• a[0] = 10 (改的是对象里面的value)
  • 这个操作是在通过变量去修改对象里面的值
  • 这个操作不会改变变量所指向的对象
• a = [4,5,6] (改的是变量)
  • 这个操作是在给变量重新赋值
  • 这个操作会让变量指向新的对象

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

a = [1,2,3]
print('修改前',a,id(a))    # 修改前 [1, 2, 3] 1669417788296
a = [4,5,6]
print('修改后',a,id(a))    # 修改后 [4, 5, 6] 1669417788808

a = [1,2,3]
b = a
b[0] = 10
print('a',a,id(a))    # a [10, 2, 3] 2114062766984
print('b',b,id(b))    # b [10, 2, 3] 2114062766984

a = [1,2,3]
b = a
b = [7,8,9]
print('a',a,id(a))    # a [1, 2, 3] 1662926902152
print('b',b,id(b))    # b [7, 8, 9] 1662926901640