python初学者，字典

1.元组简介

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

tuple1 = (1,2,3,4,5)
print(tuple1[0])  # 1

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

tuple2 = 10
print(tuple2,type(tuple2))	
#10 <class 'int'>

tuple2 = 10,
print(tuple2,type(tuple2))	
# (10,) <class 'tuple'>

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

tuple3 = 10,50,70
a,b,c = tuple3
print("a = {}".format(a))
print("b = {}".format(b))
print("c = {}".format(c))
'''
a = 10
b = 50
c = 70
'''

元组解包时，变量与元素的个数应保持一致
如不一致，必须需在最后一个变量前加一个*

tuple4 = 10,50,70,90,100
a,b,*c = tuple4
print("a = ",a)
print("b = ",b)
print("a = ",*c)
'''
a =  10
b =  50
*c =  70 90 100
'''

*a,b,c = tuple4
print("a = ",*a)
print("b = ",b)
print("a = ",c)
'''
a =  10 50 70
b =  90
a =  100
'''

2.可变对象

• 可变对象中都保存了三个数据
  • id(标识)
  • type(类型)
  • value(值)

我们可以对对象里的value进行改变。里面的value值改变，id，type不会改变。
例如：

a = [1,2,3]
print('a的初始value，type，id',a,type(a),id(a))
# a的初始value，type，id:
# [1, 2, 3] <class 'list'> 2055769309448
a[0] = 10
print('改对象：',a,type(a),id(a))
# 改对象： [10, 2, 3] <class 'list'> 2055769309448

如果对变量进行改变，会改变变量所指向的对象，里面的id，type，value都可能改变。

a = [1,2,3]
print('a的初始value，type，id',a,type(a),id(a))
# a的初始value，type，id:
# [1, 2, 3] <class 'list'> 2055769309448
a = [4,5,6] 
print('改变量：',a,type(a),id(a)) 
# 改变量： [4, 5, 6] <class 'list'> 2055770134344

当我们修改对象时，如果有其他变量也指向该对象则修改也会在其他变量中体现。
反过来，改对象的值会影响所有指向该对象的变量

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

想一想print(“b”,b,id(b)) 是什么？id会改变吗？

a = [1,2,3]
print("a",a,id(a)) #a [1, 2, 3] 2470665797896
a [10, 2, 3] 
b [10, 2, 3] 
b = a
b =[10,2,3]
print("a",a,id(a)) 
print("b",b,id(b)) 

• 不可变类型 数值类型（int和float）、字符串str、元组tuple都是不可变类型。
• 可变类型 列表list、字典dict、集合set

3.字典简介

3.1 字典的基本介绍

• 字典属于⼀种新的数据结构称为映射(mapping)
• 字典的作⽤和列表类似，都是⽤来存储对象的容器
• 列表存储数据的性能好，但是查询数据的性能差，字典正好与之相反
• 在字典中每⼀个元素都有唯⼀的名字，通过这个唯⼀的名字可以找到指定的 元素
• 这个唯⼀的名字我们称之为key 通过key可以快速查询value 也可以称之为值 字典我们也称之为键值对(key-value)结构
• 每个字典中都可以有多个键值对，⽽每⼀个键值对我们称其为⼀项(item) 创建⼀个有数据的字典
  语法

 a = {key:value,key:value} 

d = {
   'name':'小明',
   'age':'15',
   'gender':"女"
}
print(d['name'],d['age'],d['gender'])
#小明 15 女

• 字典的值可以是任意对象 字典的键可以是任意的不可变对象(int str bool tuple…)
• 字典的键是不能重复的，如果出现重复的后⾯的会替换前⾯的

3.2 字典的使⽤

• dict()函数来创建字典

d = dict(name='小明',age=15,gender='男')
print(d,type(d)) 	# {'name': '小明', 'age': 15, 'gender': '男'} <class 'dict'>

• 双值子序列转换成字典
• 双值序列 序列中只有两个值，如(x,1),“ab”,[5,6]
• 子序列 如果序列中的元素也为序列，我们称这个元素为子序列

d = dict([('name','小明'),('age','15')])
print(d,type(d))  #{'name': '小明', 'age': '15'} <class 'dict'>

• get(key[,default]) 根据键来获取字典的值。
  • 如果获取字典中的键不存在 就会返回NOne
  • 第⼆个参数可以指定⼀个默认 值，当获取不到值的时候会返回默认值。

 d = {
    'name':'小明',
    'age':'15',
    'gender':"女"
}
print(d.get('小花','该值不存在')) #该值不存在

修改字典

• 添加

d = {
    'name':'小明',
    'age':'15',
    'gender':"女"
}
d['name'] = '小花' # 修改
d['phone'] = '13185757857' #添加
print(d)
#{'name': '小花', 'age': '15', 'gender': '女', 'phone': '13185757857'}

d = {
    'name':'小明',
    'age':'15',
    'gender':"女"
}
# d['name'] = '小花'
# d['phone'] = '13185757857'
d.setdefault('name','小红') # 如key已存在到字典中，不会对key做任何操作
d.setdefault('tel','1230258') # 如key不存在，则将key添加到到字典中，并设置一个valu
print(d)
#{'name': '小明', 'age': '15', 'gender': '女', 'tel': '1230258'}

函数	作用
len()	获取字典中键值对的个数
in	检查字典中是否包含指定的键
not in	检查字典中是否不包含指定的键
update()	将其他字典的key-value添加到当前的字典当中，如有重复的key，后面的会覆盖 前面的
del()	删除字典中的key-value
popitem()	删除字典最后的⼀个key-value 这个⽅法是有返回值的。删除之 后它会将删除的key-value作为返回值返回。返回的是一个元组（key，value）
pop(key[,default])	根据key删除⾃定中的value。第⼆个参数可以指定⼀个 默认值，当获取不到值的时候会返回默认值

3.3 copye()

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

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

d = {'a':{'name':'蜘蛛侠','age':10},'b':2,'c':3}
d2 = d.copy()
d2['a']['name'] = '黑猫警长'
print('d =',d,id(d)) 
# d = {'a': {'name': '黑猫警长', 'age': 10}, 'b': 2, 'c': 3} 2508191133272
print('d2 =',d2,id(d2))
# d2 = {'a': {'name': '黑猫警长', 'age': 10}, 'b': 2, 'c': 3} 2508191132912

• 注意:潜复制只会复制字典本身，如果字典中还有个字典是不会进⾏复制的

4. 遍历字典

我们主要可以通过3种⽅式对字典进⾏遍历

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

d = {'name': '小花', 'age': 15, 'gender': '男'}

# keys() 该方法返回的是字典所有的Key
for k in d.keys():
    print(d[k])
'''
小花
15
男
'''
# values() 返回一个序列，该序列中保存有字典的值
for v in d.values():
    print(v)
    '''
小花
15
男
    '''
# items() 返回字典所有的项 它返回的是一个序列 序列包含的是双值子序列
# 双值分别是 字典中的Key和value
for k,v in d.items():
    print(k,v)
    '''
name 小花
age 15
gender 男
    '''

5.集合

5.1 集合简介

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

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

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

lst = [1,2,3,4]
print(set(lst))
#{1, 2, 3, 4}

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

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

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

s = {'a','b',1,2,3}
s.add('添加元素1')
s.add('添加元素2')
print(s)
# {1, 2, 3, 'a', '添加元素2', 'b', '添加元素1'}

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

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

• pop() 随机删除集合中的⼀个元素 返回值（被删除的元素）

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

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

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

• clear() 清空集合

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

5.2 集合的运算

s1 = {5,9,8,4,}
s2 = {9,9,4,8,}

• & 交集运算

print(s1&s2) # {8, 9, 4}

• | 并集运算

print(s1|s2)  # {4, 5, 8, 9}

• – 差集运算

print(s1-s2) # {5}

• ^ 异或集

print(s1^s2) # {5}

• <= 检查⼀个集合是否是另⼀个集合的⼦集

print(s1<=s2) # False

• < 检查⼀个集合是否是另⼀个集合的真⼦集

print(s1<s2) # False

• >= 检查⼀个集合是否是另⼀个集合的超集

print(s1>=s2) # True

• > 检查⼀个集合是否是另⼀个集合的真超集

print(s1>s2) # True

（注意:部分资料来源于网络，如有侵权请联系作者!）
下一篇：函数

上一篇：列表