python 基础学习七（元组、字典、集合）

元组

• 元组表现形式tuple，元组与列表类似，不同之处在于元组的元素不能修改

• 元组是一个不可变序列(一般当我们希望数据不改变时，我们使用元组，其他情况下基本都用列表),所谓元组的不可变指的是元组所指向的内存中的内容不可变。

• 使用()创建元素，元组创建很简单，只需要在括号中添加元素，并使用逗号隔开即可。

>>> tup1 = ('Google', 'Runoob', 1997, 2000)
>>> tup2 = (1, 2, 3, 4, 5 )
>>> tup3 = "a", "b", "c", "d"   #  不需要括号也可以
>>> type(tup3)
<class 'tuple'>

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

• 元组中只包含一个元素时，需要在元素后面添加逗号，否则括号会被当作运算符使用

>>> tup1 = (50)
>>> type(tup1)     # 不加逗号，类型为整型
<class 'int'>

>>> tup1 = (50,)
>>> type(tup1)     # 加上逗号，类型为元组
<class 'tuple'>

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

tup1=(1,2,3,4,5)
a,b,c,d,e=tup1
print(a,b,c,d,e)
1 2 3 4 5

• 元组与字符串类似，下标索引从 0 开始，可以进行截取，组合等

修改元组

元组中的元素值是不允许修改的，但我们可以对元组进行连接组合，如下实例:

tup1 = (12, 34.56)
tup2 = ('abc', 'xyz')
 
# 以下修改元组元素操作是非法的。
# tup1[0] = 100
 
# 创建一个新的元组
tup3 = tup1 + tup2
print (tup3)
(12, 34.56, 'abc', 'xyz')

元组中的元素值是不允许删除的，但我们可以使用del语句来删除整个元组，如下实例:

tup = ('Google', 'Runoob', 1997, 2000)
 
print (tup)
del tup
print ("删除后的元组 tup : ")
print (tup)

以上实例元组被删除后，输出变量会有异常信息，输出如下所示：

删除后的元组 tup : 
Traceback (most recent call last):
  File "test.py", line 8, in <module>
    print (tup)
NameError: name 'tup' is not defined

元组运算符

与字符串一样，元组之间可以使用 + 号和 * 号进行运算。这就意味着他们可以组合和复制，运算后会生成一个新的元组。

tuple(iterable)将可迭代系列转换为元组。

>>> list1= ['Google', 'Taobao', 'Runoob', 'Baidu']
>>> tuple1=tuple(list1)
>>> tuple1
('Google', 'Taobao', 'Runoob', 'Baidu')

字典

字典的基本介绍

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

字典的使用

• dict()函数来创建字典
• get(key[,default]) 根据键来获取字典的值。第二个参数可以指定一个默认值，当获取不到值的时候会返回默认值

dict1={1:2,2:3,3:4}
print(dict1.get(5))
>>> None
# 找不到对应值的时候会报错
print(dict1[5])

• update() 将其他字典的key-value添加到当前的字典当中

dict1={1:2,2:3,3:4}
dict1.update({4:5})
print(dict1)
>>> {1:2,2:3,3:4,4:5}

• del 删除字典中的key-value或者删除整体

dict1={1:2,2:3,3:4}
del dict1[3]
print(dict1)
>>> {1:2,2:3}

• popitem() 删除字典最后的一个key-value 这个方法是有返回值的。删除之后它会将删除的key-value以元组类型作为返回值返回

dict1={1:2,2:3,3:4}
print(dict1.popitem())
print(dict1)
>>> (3,4)
>>> {1:2,2:3}

• pop(key[,default]) 根据key删除自定中的value。第二个参数可以指定一个默认值，当获取不到值的时候会返回默认值

dict1={1:2,2:3,3:4}
print(dict1.pop(4,0))
print(dict1.pop(3))
print(dict1)
>>> 0
>>> 4
>>> {1:2,2:3}

copy()

copy() 方法用来对字典进行浅复制
注意:浅复制只会复制字典第一层数据，如果字典中还有个字典是不会进行复制的

dict1={1:2,2:3,3:4}
dict2=dict1.copy()
print(dict2)
>>> {1:2,2:3,3:4}

遍历字典 — 返回一个迭代器，可以使用 list() 来转换为列表

我们主要可以通过3种方式对字典进行遍历
• keys() 该方法返回字典所有的key

dict1={1:2,2:3,3:4}
for i in dict1.keys():
    print(i)
>>> 1 2 3

• values() 该方法返回一个序列 序列中保存有字典的值

dict1={1:2,2:3,3:4}
for i in dict1.values():
    print(i)
>>> 2 3 4

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

dict1={1:2,2:3,3:4}
for i in dict1.items():
    print(i)
>>> (1,2) (2,3) (3:4)  
dict1={1:2,2:3,3:4}
for i,j in dict1.items():
    print(i,j)
>>> 1 2 2 3 3 4

集合

• 集合表现形式set

不同点

• 集合只能存储不可变对象

• 集合中存储的对象是无序的

• 集合不能出现重复元素

• 使用{}来创建集合
• 可以通过set()来将序列和字典等可迭代对象转换成集合
  set1=set('123456789')
  print(set1)
  >>> {'7', '1', '4', '6', '5', '9', '8', '2', '3'}

• len() 使用len()来获取集合中元素的数量
  set1=set('123456789')
  print(len(set1))
  >>> 9

• add() 向集合中添加元素
  set1=set('123456789')
  set1.add((1,2))
  print(set1)
  >>> {(1, 2), '8', '4', '7', '9', '5', '3', '2', '1', '6'}
  
• update() 将一个可迭代对象中的元素添加到另一个集合当中
  set1=set('123456789')
  set1.update([1,2])
  print(set1)
  >>> {1, '5', 2, '4', '3', '9', '7', '1', '2', '6', '8'}
  
• pop() 随机删除集合中的一个元素,删除前面的
  set1=set('123456789')
  print(set1)
  print(set1.pop())
  >>> {'1', '9', '7', '3', '8', '5', '2', '4', '6'}
  >>> 1
• remove() 删除集合中指定的元素
  set1=set('123456789')
  set1.remove('1')
  print(set1)
  >>> {'8', '9', '2', '3', '6', '4', '7', '5'}

• clear() 清空集合
  set1=set('123456789')
  set1.clear()
  print(set1)
  >>> set()  

集合的运算

• & 交集运算
set1={1,2,3,4,5,6}
set2={6,7,8,9}
print(set1 & set2)
>>> {6}

• | 并集运算
set1={1,2,3,4,5}
set2={6,7,8,9}
print(set1 | set2)
>>> {1, 2, 3, 4, 5, 6, 7, 8, 9}

• - 差集运算
• ^ 亦或集(取出不同的)
set1={1,2,3,4,5,6}
set2={6,7,8,9}
print(set1 ^ set2)
>>> {1, 2, 3, 4, 5, 7, 8, 9}

• <= 检查一个集合是否是另一个集合的子集
• < 检查一个集合是否是另一个集合的真子集
• >=检查一个集合是否是另一个集合的超集
set1={1,2,3,4,5,6}
set2={1,3,5}
print(set1 >= set2)
>>> True

• >检查一个集合是否是另一个集合的真超集
set1={1,2,3,4,5,6}
set2={1,3,5}
print(set1 > set2)
>>> True

练习

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

# 数据的嵌套，最外层是一个字典，首先将data提取出来，然后提取result，最后提取每一个值
a = {"name":"123","data":{"result":[{"src":"python1"},{"src":"python2"},{"src":"python3"}]}}

print(a['data']['result'][0]['src'])
print(a['data']['result'][1]['src'])
print(a['data']['result'][2]['src'])

2、有如下值集合[11,22,33,44,55,66,77,88,99,90], 将所有大于66的值保存至字典的第一个key的值中，将小于66值保存至第二个key的值中

set1=set([11,22,33,44,55,66,77,88,99,90])
dict1={}
list1=[]
list2=[]

for i in set1:
    if i > 66:
        list1.append(i)
    else:
        list2.append(i)

dict1[1]=list1
dict1[2]=list2

print(dict1)