元组&字典知识大全

1.元组（tuple)

1.1.元组定义

• 元组是由（）和“，”构成。（）把元素括起来，并用“，”把元素隔开。（）里面必须有逗号，否则，则是int类型，仅有逗号也是元组。

a = 1,2,3
print(type(a))
b = (1,2,3)
print(type(b))
c = (1,)
print(type(c))

• 元组是不可变序列。不希望数据发生改变的时候我们就用元组，其余的情况都用列表。元组和列表十分相似，大部分方法通用，最大区别是，列表可以修改，读取，删除，元组创建之后不能修改，删除单个元素，只能删除整个元组。

1.2.拆包

1.2.1 元组拆包

a = (1, 2)
b, c = a
print(b, c)

1,2

这两种种情况报错

a = (1,2,3)
b,c = a
print(b, c)

b, c = a
ValueError: too many values to unpack (expected 2)

a = (1,2,)
b,c，d = a
print(b, c,d)

b, c,d = a
ValueError: not enough values to unpack (expected 3, got 2)

• 拆包的时候如果有*， 那么有且只能有一个*, *数之后接受参，结果是用一个列表来放置的

tuple4 = (1, 2, 3, 4)
a, *b, c = tuple4
print(a, b, c)

1 [2, 3] 4

1.2.2字符串的拆包

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

1.2.3列表的拆包

list1 = [1, 2, 3, 4, 5]
 a, *b = list1
 print(a, b)

2.字典

2.1字典简介

2.1.1字典的基本介绍

• 字典是一种数据结构，是和列表一样的可变序列
• 在字典中每一个元素都有唯一的名字，通过这个唯一的名字可以找到指定的元素
• 这个唯一的名字我们称之为key 通过key可以快速查询value 也可以称之为值
• 字典我们也称之为键值对(key-value)结构
• 每个字典中都可以有多个键值对，而每一个键值对我们称其为一项(item)
• 字典的元素都是成对出现的，每个元素都是由“，”和键值对key:value构成，元素之间用“，”隔开。字典的键必须是唯一的，不重复的
• 创建一个有数据的字典 语法 {key:value}

dict = {'name':'张三丰','age':'18','sex':'男','skill':'降龙十八掌'}
print（dict）
dict1 = {
   'name': '张三丰',
       'age': '18',
       'sex': '男',
       'skill': '降龙十八掌'
}
print(dict1,type(dict1))

 {'name': '张三丰', 'age': '18', 'sex': '男', 'skill': '降龙十八掌'
{'name': '张三丰', 'age': '18', 'sex': '男', 'skill': '降龙十八掌'} <class 'dict'>

• 创建空字典

dict = {}
print(dict,type(dict))

{} <class 'dict'>

• 当字典中的key重复时，后面的key-value后替换前面的
• 获取value，通过变量名[key]

dict2 = = {
         'name': '郭靖',
          'age': 18,
          'sex': '男',
          'name': '欧阳锋',
         'skill': '蛤蟆功'
 }
print(dict2['skill'])

• 字典的值可以是任意对象 字典的键可以是任意的不可变对象(int str bool tuple…)

dict = {
    (1, 2, 3): '张三丰',
        'age': '18',
        'sex': '男',
        'skill': '降龙十八掌'
}

2.1.2 字典的使用

• dict()函数来创建字典

# 1. {}

# 2. 使用dict类去创建字典
dict1 = dict(name='郭靖', age=18, sex='男')
print(dict1, type(dict1))

# 3. 使用dict去创建,这种方法出现在python2中，有有序字典 orderdict  无序字典之分，python3中也适用。现在的字典都是有序字典，无无序字典了
# 需要dict（）括号里的数据是属于一种双值子序列的形式
# 双值序列 [1, 2]
# 子序列  （'a'）
# 双值子序列： [(1, 2), (3, 4)]
dict2 = dict([('name', '郭靖'), ('age', 18), ('sex', '男')])
print(dict2, type(dict2))

• in和not in 是用来检测key的，不是检测value

dict = dict([('name','豪豪'), ('age', '19'), ('sex','男',
('girlfriend','无')])
print(len(dict))
print('name' in dict,'\n', 19 in dict)

 豪豪
True 
 False

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

dict = dict([('name','豪豪'), ('age', '19'), ('sex','男'), ('girlfriend','无')])
print(dict.get("woow"),'我爱你',['真的'])

None 我爱你 ['真的']

• 利用变量名.get(key)获取value,如果key不存则返回None值,

dict = dict([('name','豪豪'), ('age', '19'), ('sex','男'), ('girlfriend','无')])
print(dict.get("woow"))

None

• 而dict[key] 如果不存在key则会报错
• 修改字典

•      #         dict[key] = value
       dict1 = dict(name='郭靖', age=18, sex='男')
       dict1['name'] = '欧阳锋'
         print(dict1)
  

* dict.setdefault(key, [default])  向字典中添加key-value
 如果这个key已经存在于字典中，则返回value，不会对字典有影响, 如果不存在，则向字典中添加这个key，并设置value
 ```python 
result = dict1.setdefault('name', '欧阳锋')
result = dict1.setdefault('skill', '降龙十八掌')
print(result)
print(dict1)

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

d1 = {'1': 1}
d2 = {'2': 2}
d1.update(d2)
print(d1)

{'1': 1, '2': 2}

• 关键字 del 删除字典中的key-value

del dict1['name']
print(dict1)

• dict.popitem() 随机删除一个键值对，一般都会删除最后一个, 有一个返回值，就是你删除的对象，结果是一个元组

dict1 = dict(name='郭靖', age=18, sex='男')
result = dict1.popitem()
print(result)
print(dict1)

• dict.pop(key，[default]) 根据key来删除键值对, 返回值就是你删除key对应的value

dict1 = dict(name='郭靖', age=18, sex='男')
result = dict1.pop('sex')
 result = dict1.pop('skill', '你删除的这个不存在')
 print(result)
 print(dict1)

 # dict.clear（） 清空字典
 dict1.clear()
 print(dict1)

list1 = [1, 2, 3, 4, 5]
list1.clear()
print(list1)

2.2.拷贝

2.2.1浅拷贝

• 浅拷贝的对象是可变类型

import copy
dict1 = {'1':1, '2':2, 'list':[1, 2, 3, {'name':[12, 23]}}
dict2 = copy.copy(dict1)#import copy,调用copy模块
print(id(dict1),id(dict2))
print(id(dict1['list']).id(dict2['list']))

2492541300952 2492542178792
2492543650248 2492543650248

• copy() 方法用来对字典进行潜复制
  注意:潜复制只会复制字典本身，如果字典中还有个字典是不会进行复制的(copy之后id就会改变)
• dict2 = dict1.copy()。与调用copy模块效果一样。

2.2.2深拷贝

• 深拷贝则可以对所有的数据全部进行拷贝，形成一个新的id

import copy
dict1 = {'1':1, '2':2, 'list':[1, 2, 3, {'name':[12, 23]}}
dict3 = copy.deepcopy(dict1)
print(id(dict1), id(dict3))
print(id(dict1['list1']), id(dict3['list1']))

2142016172248 2142017050160
2142018517320 2142018518472

3.字典的遍历

• 通过key来遍历出value,变量名.keys()

dict1 = dict(name = '豪豪'， age = '18',sex = '男')
for k in dict1.keys():
	print(dict1[k])

• 通过value来遍历出value，变量名.values()
• 通过一项来遍历。变量名.items()

dict1 = dict(name = '豪豪'， age = '18',sex = '男')
for k,v in dict1.items():
print(k , "=", v )

3.作业

3.1元组切片&索引

tuple1 = (1, 2, 3, 4, 5, 6)
print(tuple1[::])
print(tuple1[:])
print(tuple1[::-1])
print(tuple1[1::-1])
print(tuple1[1:0:-1])
print(tuple1[1:5:-1])
print(tuple1[5:1:-1])
print(tuple1[-1:-5:-1])
print(tuple1[-1:-5])
print(tuple1[-2:-5])

print(type(tuple2), type(tuple3), type(tuple4))

• 结果

(1, 2, 3, 4, 5, 6)
(1, 2, 3, 4, 5, 6)
(6, 5, 4, 3, 2, 1)
(2, 1)
(2,)
()
(6, 5, 4, 3)
(6, 5, 4, 3)
()
()

3.2.测试元组类型

tuple1 = ()
print(tuple1, type(tuple1))
tuple2 = 1,
tuple3 = (1)
tuple4 = (1,)
print(type(tuple2), type(tuple3), type(tuple4))

() <class 'tuple'>
<class 'tuple'> <class 'int'> <class 'tuple'>

3.3.拆包

• 拆包的时候如果有*， 那么有且只能有一个*, *接受参数之后，结果是用一个列表来放置的,(字符串，列表拆包与元组一样）

tuple1 = (1, 2, 3, 4, 5, 6)
a, b = tuple1
print(a, b)

a, b = tuple1
ValueError: too many values to unpack (expected 2)

tuple1 = (1, 2)
a, b = tuple1
print(a, b)

1 2

tuple1 = (1, 2, 3, 4, 5,)
a, *b, c = tuple1
print(a, *b, c)

1 2 3 4 5

tuple1 = (1, 2, 3, 4, 5,)
a, *b, c = tuple1
print(a, b, c)

1 [2, 3, 4] 5

3.4 第二题

• 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"}]}}

for i in range(3):
    print(a['data']['result'][i]['src'])

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

a  = [11,22,33,44,55,66,77,88,99,90]
list1 = []
list2 = []
dict = {}
for i in a:
    if i > 66:
        list1.append(i)
    elif i < 66:
        list2.append(i)

dict['key1'] = list1
dict['key2'] = list2

print(dict)