Python数据类型之元组及字典

元组（tuple）

• 元组表现形式tuple
• 元组是一个不可变序列
• 使用()创建元素
• 元组不是空元组至少有一个 逗号(,) 当元组不是空元组时括号可以省略
• 元组解包指将元组当中的每一个元素都赋值给一个变量
• 使用()创建的

my_tuple = () # 创建一个空的元组

什么时候用列表什么时候用元组：一般当我们希望数据不改变时，我们使用元组，其他情况下基本都用列表

添加元素

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

my_tuple[3] = 10 # 报错，因为元组不可变！
# 如果一个元组不是空的元组，那么它里面至少需要一个 ，
# 来变成元组
my_tuple = 10,

my_tuple = 10,20,30,40

a,b,c,d = my_tuple

print(my_tuple,type(my_tuple))

解包

# 元组的解包
# 元组的解包指的是将元组当中的每一个元素都赋值给一个变量
print('a =',a)
print('b =',b)
print('c =',c)
print('d =',d)

# 解包应用场景，切换值
a = 6
b = 8
# b,a = a,b 意思就是左边的b赋值给右边的a
# 			左边的a赋值给右边的b
b,a = a,b

# java或c都要用中间变量
temp = a
a = b
b = temp

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

拓展

• 在对一个元组解包时，变量的数量必须和元组中的元素要一一对应
• 如果出现变量和元素没有对等的情况下，我们可以在变量前面加一个*（有且仅有一个 *；元组可以使用 *列表也可以 ）
• 这样变量就会将获取元组中所有剩余的元素以列表的形式返回

my_tuple = 10,20,30,40

a,*b,c = my_tuple # 10 [20, 30] 40
*a,b,c = my_tuple # [10, 20] 30 40

a,b,*c = [1,2,3,4,5,6,7]	
a,b,*c = 'python java'  # 输出前两个字母，后面几个字符串（str）放进元组里分别存储

*a = my_tuple # 语法不对，元组要一一对应剩下的！再放进* 里
print(a,)

内存：

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

 通过索引来改变列表
a[0] = 10

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

 为变量赋值
a = [4,5,6]

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

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

运算符

• == != 比较的是对象的值是否相等
• is is not 比较的是对象的id是否相等(比较两个对象是否是同
  一个对象)

a = [1,2,3]
b = [1,2,3]
print(a,b) # 输出数组
print(id(a),id(b)) # 输出id
print(a is b) # false或True

字典(dict)

语法 {key:value,key:value,key:value}
d = {'name':'钢铁侠','age':30,'sex':'男'}


也可以使用 dict()函数来创建字典
d = dict(name='钢铁侠',age=30,sex='男')

字典的键可以是任意不可变对象(int str bool tuple…)
字典的值可以是任意对象
字典当中的键是不可以重复的，如果重复后边的会替换前边的

d = {'name':'钢铁侠','age':30,'sex':'男','name':'葫芦娃'}
d = {
    'name':'钢铁侠',
    'age':18

}

可以根据键来获取值

print(d['name'],d['age'],d['sex'])

可以将一个包含有双值子序列的序列转换为字典
双值序列，序列当中只有2个值 [1,2] (‘b’,6) ‘de’
子序列: 如果序列当中的元素也是序列，那么我们就称之为这个元素的子序列

例如: [(2,3),(7,8)]
d = dict([(‘name’,‘钢铁侠’),(‘age’,18)])

获取字典当中的长度 len()

in 检查字典当中是否包含指定的键
not in 检查字典当中是否不包含指定的键
print('Hello'in d)


获取字典当中的值 根据键来获取
语法 d[key]

w = 'name'
语法： get(key[, default])
print(d.get('python'))# 检查字典里是否有get里的字符串
				   	# 若没有字符串，不会报错 且返回None
print(d.get('python','66')) # 若没有字符串返回后面一个引号的值

修改字典

d[key] = value
如果Key值存在覆盖，不存在就添加
d['name'] = '葫芦娃'
d['phone'] = '13456'

setdefault()
setdefault(key[, default]) 就是像字典中添加key-value
如果Key已经存在字典中，则返回key的值，不会对字典做任何操作:
d = dict([('name','钢铁侠'),('age',18)])
result= d.setdefault('name','葫芦娃')
print(result) 
打印结果：
> 钢铁侠

如果Key不存在，则向字典中添加这个Key,并设置value
d = dict([('name','钢铁侠'),('age',18)])
result= d.setdefault('python','葫芦娃')
print(result) 
打印结果：
> 葫芦娃
print(d) # 打印字典会发现在字典里的最后添加了key-value:  'python'：'葫芦娃' 


update()
将其他字典当中的key-value 添加到当前字典当中
 如果有重复的key，则后边的会替换到前面的
d = {'a':1,'b':2,'c':3}

d2 = {'d':4,'e':5,'f':6}

d.update(d2)


 删除
del d['a']
del d['b']

popitem() 随机删除字典中的一个键值对，一般都会删除最后一个键值对
删除之后他会将删除的key-value 作为返回值返回
返回值是一个元组，元组中有2个元素 第一个是删除的Key 第二个是删除的value
d.popitem() # {'c': 3, 'd': 4, 'e': 5}
result = d.popitem() # {'c': 3, 'd': 4}
print(result)


clear() 清空字典
d.clear()
print(d)


copy() 该方法是用来对字典进行一个潜复制

复制以后的对象 和原对象就是对立 修改一个不会影响第二个
d = {'a':1,'b':2,'c':3}

d2 = d

 d['b'] = 10

d2 =d.copy()
d['a'] = 88
潜复制会简单复制对象内部的值，如果这只也是一个可变对象，这个可变对象是不会被复制的
d = {'a':{'name':'钢铁侠','age':30},'b':2,'c':3}

d2 =d.copy()

print('d = ',d,id(d))

print('d2 = ',d2,id(d2))

注：浅的意思：只对最外层字典起作用，如果有嵌套字典，想要修改内部字典属性，则内部字典会随着修改 d 和d2 里的值都会发生变化

字典的遍历

keys()
values()
items()


keys()
d = {'name':'钢铁侠','age':30,'sex':'男'}

通过遍历keys()来获取所有的键

for k in d.keys():
    print(k,d[k])

values()

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

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

print(d.items())

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