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

4.集合

4.1 集合简介

• 集合表现形式set 集合和列表非常相似
• 不同点
  • 集合只能存储不可变对象
  • 集合中存储的对象是无序的
  • 集合不能出现重复元素
• 使用{}来创建集合
• 常用相关函数及方法

函数或方法	功能
set()	将序列和字典转换成集合
len()	获取集合中元素的数量
add()	向集合中添加元素
update()	将一个集合中的元素添加到另一个集合当中
pop()	随机删除集合中的一个元素一般是删除最后一个元素
remove()	删除集合中指定的元素
clear()	清空集合

# 集合
my_set = {1,10,3,2,78,6,6,6,6}
# 重复元素只显示一次，存储对象无序
print(my_set,type(my_set))      #{1, 2, 3, 6, 10, 78} <class 'set'>
# set()
my_list = [1,3,5,7,4,2]
my_set = set(my_list)
print(my_set,type(my_set))      #{1, 2, 3, 4, 5, 7} <class 'set'>
# len()
my_set = {1,3,5,7,4,2}
print(len(my_set))              #6
# add()
my_set = {1,3,5,7,4,2}
my_set.add('new')
print(my_set)                   #{1, 2, 3, 4, 5, 7, 'new'}
# update()
my_set = {1,3,5,7,4,2}
my_set.update({1,'hello'})      #{1, 2, 3, 4, 5, 7, 'hello'}
print(my_set)
# pop()
my_set = {1,3,5,7,4,2}
pop_num = my_set.pop()
print(pop_num,my_set)           #1 {2, 3, 4, 5, 7}
# remove()
my_set = {1,3,5,7,4,2}
my_set.remove(1)
print(my_set)                   #{2, 3, 4, 5, 7}
# clear()
my_set = {1,3,5,7,4,2}
my_set.clear()
print(my_set)                   #set()

4.2 集合的运算

• 常见的用于集合运算的符号及功能如下表所示：

符号	功能
&	交集运算，取两集合的共同部分
|	并集运算，取两集合所有包含的元素
-	差集运算，从前一集合中除去与第二集合共同的部分
^	亦或集运算，取两集合的不同部分
<=	检查一个集合是否是另一个集合的子集
<	检查一个集合是否是另一个集合的真子集
>=	检查一个集合是否是另一个集合的超集
>	检查一个集合是否是另一个集合的真超集

# 集合的运算
# &   |   -   ^   <=   <   >=   >
set_1 = {1,2,3,6,7,8}
set_2 = {1,2,3,4,5}
set_3 = {1,10}
set_4 = {1,5,10}
set_5 = {1,5,10}
print(set_1)                    #{1, 2, 3, 6, 7, 8}
print(set_2)                    #{1, 2, 3, 4, 5}
print(set_1 & set_2)            #{1, 2, 3}
print(set_1 | set_2)            #{1, 2, 3, 4, 5, 6, 7, 8}
# 差集运算时谁放在前面谁放在后面是不一样的
print(set_1 - set_2)            #{8, 6, 7}
print(set_2 - set_1)            #{4, 5}
print(set_1 ^ set_2)            #{4, 5, 6, 7, 8}
print(set_1 <= set_2)           #False
print(set_3 <= set_4)           #True
print(set_1 < set_2)            #False
print(set_4 < set_5)            #False
print(set_1 >= set_2)           #False
print(set_4 >= set_5)           #True
print(set_1 > set_2)            #False
print(set_4 > set_3)            #True

小试牛刀

• a = {“name”:“123”,“data”:{“result”:[{“src”:“python1”},{“src”:“python2”},{“src”:“python3”}]}} 找到python1/python2/python3

# 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']