python元组和字典

1.可变对象

字如其名，可变对象一旦创建之后还可改变但是地址不会发生改变，即该变量指向的还是原来的对象。
在Python中，数值类型（int和float）、字符串str、元组tuple都是不可变类型。而列表list、字典dict、集合set是可变类型
可变对象中都保存了三个数据：

• id(标识)
• type(类型)
• value(值)

# --不可变对象--
# 数值类型（int和float）、字符串str、元组tuple都是不可变类型
my_num = 5.2
before_id = id(my_num)
my_num = 7.6
after_id = id(my_num)
print(before_id == after_id)            #False

my_str = 'Nathaniel'
before_id = id(my_str)
my_str = 'Nathaniel'+'!'
after_id = id(my_str)
print(before_id == after_id)            #False

my_tuple = (1,2,3)
before_id = id(my_tuple)
my_tuple = my_tuple + (4,5)
print(my_tuple)                         #(1, 2, 3, 4, 5)
after_id = id(my_tuple)
print(before_id == after_id)            #False
# --可变对象--
# 列表list、字典dict、集合set是可变类型
my_list = ['I','am','Nathaniel']
before_id = id(my_list)
my_list[1] = 'am not'
print(my_list)                          #['I', 'am not', 'Nathaniel']
after_id = id(my_list)
print(before_id == after_id)            #True
# id(标识)
# type(类型)
# value(值)
print(my_num,id(my_num),type(my_num))   #7.6 1760922411440 <class 'float'>
print(my_list,id(my_list),type(my_list))#['I', 'am not', 'Nathaniel'] 2236592317000 <class 'list'>

2.元组介绍

元组基本介绍：

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

# 元组
my_tuple = ()               #创建空元组
print(type(my_tuple))       #<class 'tuple'>
# 元组不是空元组至少有一个 逗号(,)  当元组不是空元组时括号可以省略
my_tuple = 'fruit','vegetable'
print(type(my_tuple))       #<class 'tuple'>
# 元组解包指将元组当中的每一个元素都赋值给一个变量
lunch,dinner = my_tuple
print(lunch,dinner)         #fruit vegetable

3.字典

3.1 字典的基本介绍

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

# 字典
# 创建一个有数据的字典 语法 {key:value}
# 可以有多个键值对
score = {'Tom':'A','Jerry':'B'}
print(type(score))              #<class 'dict'>
# 字典的键是不能重复的，如果出现重复的后面的会替换前面的
score = {'Tom':'A','Jerry':'B','Tom':'C'}
print(score)                    #{'Tom': 'C', 'Jerry': 'B'}

3.2 字典的使用

方法或函数	功能
dict()	创建字典
get(key[,default])	根据键来获取字典的值。第二个参数可以指定一个默认值，当获取不到值的时候会返回默认值
update()	将其他字典的key-value添加到当前的字典当中
del	删除字典中的key-value
popitem()	删除字典最后的一个key-value。 这个方法是有返回值的。删除之后它会将删除的key-value作为返回值返回
pop(key[,default])	根据key删除自定中的value。第二个参数可以指定一个默认值，当获取不到值的时候会返回默认值

# 字典的使用
# dict()
my_dic = dict((['Tom','D'],['Jerry','C']))
print(my_dic)                       #{'Tom': 'D', 'Jerry': 'C'}
# get(key[,default])
my_dic = dict((['Tom','D'],['Jerry','C']))
name = 'Tom'
score = my_dic.get(name,name+' not exist!')
print(score)                        #D
name = 'Nathaniel'
score = my_dic.get(name,name+' not exist!')
print(score)                        #Nathaniel not exist!
# update()
my_dic = dict((['Tom','D'],['Jerry','C']))
my_dic.update({'Nathaniel':'S'})
print(my_dic)                       #{'Tom': 'D', 'Jerry': 'C', 'Nathaniel': 'S'}
# del
my_dic = dict((['Tom','D'],['Jerry','C']))
del my_dic['Tom']
print(my_dic)                       #{'Jerry': 'C'}
# popitem()
my_dic = dict((['Tom','D'],['Jerry','C']))
member = my_dic.popitem()
print(member)                       #('Jerry', 'C')
print(my_dic)                       #{'Tom': 'D'}
# pop(key[,default])
my_dic = dict((['Tom','D'],['Jerry','C']))
name = 'Tom'
my_dic.pop(name)
print(my_dic)                       #{'Jerry': 'C'}

3.3 copy()

copy() 方法用来对字典进行浅拷贝
注意:浅拷贝只会拷贝字典本身，如果字典中还有个字典（列表）是不会进行拷贝

# copy()
# 其中'Teachers'对应的值也为字典
my_dic = dict({'Teachers':{'Tom':'Professor','Jerry':'Master'},'Students':'Nathaniel'})
print(my_dic)                           #{'Teachers': {'Tom': 'Professor', 'Jerry': 'Master'}, 'Students': 'Nathaniel'}
your_dic = my_dic.copy()
print(your_dic)                         #{'Teachers': {'Tom': 'Professor', 'Jerry': 'Master'}, 'Students': 'Nathaniel'}
your_dic['Teachers']['Tom'] = 'Bachelor'
print(your_dic)                         #{'Teachers': {'Tom': 'Bachelor', 'Jerry': 'Master'}, 'Students': 'Nathaniel'}}
print(my_dic)                           #{'Teachers': {'Tom': 'Bachelor', 'Jerry': 'Master'}, 'Students': 'Nathaniel'}

3.4 遍历字典

我们主要可以通过3种方式对字典进行遍历：

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

# 遍历字典
my_dic = {'A':3,'B':5,'C':6,'D':9,'E':1}
# keys()
for key in my_dic.keys():
    print(key)
# A
# B
# C
# D
# E

# values()
for value in my_dic.values():
    print(value)
# 3
# 5
# 6
# 9
# 1

# items()
for key,value in my_dic.items():
    print(key,value)
# A 3
# B 5
# C 6
# D 9
# E 1

练习

# a = {“name”:“123”,“data”:{“result”:[{“src”:“python1”},{“src”:“python2”},{“src”:“python3”}]}}
# 找到python1/python2/python3
# 分析：a为字典，两个键值对，其中第二个键值对中的值为只有一个键值对的字典，且这个字典中的值为一个包含三个最内层字典的列表
a = {"name":"123","data":{"result":[{"src":"python1"},{"src":"python2"},{"src":"python3"}]}}
my_find = []
for num in range(0,3):
    my_find.append(a['data']['result'][num]['src'])
print(my_find)                          #['python1', 'python2', 'python3']