旅途——Python：元组和字典

元组

简介：

• 元组基本介绍
  • 元组表现形式tuple
  • 元组是一个不可变序列(一般当我们希望数据不改变时，我们使用元组，其他情况下基本都用列表)
  • 使用()创建元素
  • 元组不是空元组至少有一个 逗号(,) 当元组不是空元组时括号可以省略
  • 元组解包指将元组当中的每一个元素都赋值给一个变量

元组的基本操作：

• ()创建元组：

my_tuple = ()#创建一个空元组
my_tuple = (1，2，3，4，5)#创建一个元组
my_tuple = 10,20，30#相当于 my_tuple =（10，20，30）元组非空可以省略（）

注意：
1、元组和列表操作差不多，用索引来查看元素
2、 但是元组不可以改变值
3、 元组不为空，则至少要一个（，）逗号

• 元组的解包：

my_tuple = 10,20，30,40
a,b,c,d =my_tuple #把元组里面的值赋值给变量,变量个数必须等于元素个数
print('a=' ,a)
print('b=' ,b)
print('c=' ,c)
print('d=' ,d)

• 当只需要部分数据时，不想要那么多的变量：

my_tuple = 10,20，30,40
a,b,*c =my_tuple # *c 获取元组剩余的元素，c是一个列表
print('a=' ,a)
print('b=' ,b)
print(*c)
print(c)

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

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

注意：这种操作列表、字符串 也可以

可变对象

• Python中，数值类型（int和float）、字符串str、元组tuple都是不可变类型。而列表list、字典dict、集合set是可变类型
• 可变对象中都保存了三个数据
  • id(标识)
  • type(类型)
  • value(值)
  （就是指我们可以对对象里面的value进行改变）

a = [1,2,3]
a[0]=10
a = [4,5,6]

注意：

• 这两种操作不一样：

  第一个是改变value
  第二个是重新开辟了一个 id ：新建了一个a，把原来的a覆盖了

• 列表是一个可变对象：
  a[0]=10 #修改对象的value，不改变id
  a = [4,5,6] #修改a的值，但是改变了对象，因为id变了
  改变对象的值会影响所有指向该对象的其他变量

字典

简介：

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

基本操作：

• 创建一个字典：字典的值可以是任意对象

• 注意：字典的key可以是任意不可变对象，切不可以重复，要不然后面的会替换前面的

# d = {key:value,......}
d = {'name':'spademan','age':7}

d = {
'name':'spademan',
'age':7
}

print(d['name']['age']) #查看对应键的值

-通过dict（）创建函数

#通过dict（）创建函数
d = dict('name':'spademan','age':7)
d = dict([('name','spademan'),('age',7)])# 如果序列中的元素也是序列，我们就称这个元素为子序列， 双值子序列

• len():获得键值对个数
• in not in :判断字典中是否包含指定的键
• 获取字典的值：dict[‘key’]
  注意：有一种特殊情况：
  n = ‘key’
  dict[n] #这样子通过变量查询
• get(key[ , default])该方法可以根据字典的key来获取值
  如果键不存在，就会返回none
  字典名.get(‘key’) #也可以获得值

修改字典：

• d[key]= value
• d[‘原字典没有的key’] = value #添加一个新的K-V对
• d.setdefault(key[ , default])字典中添加新的K-V对

d.setdefault('name','Tom')
#如果key已经存在在字典当中，则返回key的值，不会对字典进行操作
#如果不存在，则向字典添加这个key，并设置value

• update():

d.update(新字典)：把d的K-V添加到新字典中，重复的key会覆盖

• del删除k-v

del d['key']

• popitem():随机删除
  d.popitem():一般删除最后一个，并且将删除的K-V作为返回值，返回元组
• pop()，会将删除的值返回
  d.pop(key[ , default]):根据key删除字典中的value
• copy():复制的两个互相不影响
• 浅复制：只会复制字典的本身，双层字典是不会被复制的，

d = {'a':1,'b':2,'c':3}
d2=d #创建d的一个副本，不是复制，因为两个变量指向同一个对象
d['b']=50 #那么d2 d都是50了

d2 = d.copy() # 此时d2,d的id不一样了，说明二者没什么关系了，此时改变d，不会影响d2
-----------------------------------------------------------

d = {'a':{'name':'Tom','age':20},'b':2,'c':3}
d2 = d.copy()
d2['a']['name'] = 'Jerry' # 此时两个都变了
#浅复制，只会复制字典本身，如果字典里还有字典，那么这个字典是不会被复制的

遍历字典：

1 keys() 返回字典所有的key
2 values() 返回一个序列，保存字典的值
3 items() 返回字典所有的项 ，返回双值子序列（key，value）

d = {'name':'spademan','age':7}

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

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

print(d.items())
for K,V in d.items():
	print(K,V)