第八章：元组和字典

01-序列-元组简介

元组 tuple
元组是一个不可变序列

一般希望数据不改变的时候，就是用用元组。其余情况都是使用列表

创建元组

使用（）创建的
my_tuple = ()  #创建一个空的元组

添加元素

my_tuple = (1,2,3,4,5)

# my_tuple[3] = 10  元组是一个不可变序列 
print(my_tuple,type(my_tuple))
>>>
(1, 2, 3, 4, 5) <class 'tuple'>

my_tuple = (1,2,3,4,5)
print(my_tuple[0])
print(my_tuple[3])
》》》
1
4

# 如果一个元组不是空的元组，那么它里面至少需要一个逗号
my_tuple1 = 10,  # 这是一个元组
my_tuple2 = 10,20,30,40   # 这也是一个元组
print(my_tuple1,my_tuple2)
>>>
(10,) (10, 20, 30, 40)

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

my_tuple = 10,20,30,40   # 这也是一个元组

a,b,c,d = my_tuple
print('a =',a)
print('b =',b)
print('c =',c)
print('d =',d)
》》》
a = 10
b = 20
c = 30
d = 40

这也是一个解包的过程
a = 6
b = 8

b,a = a,b
temp = a      # temp = a =6
a = b         # a = b = 8
b = temp      # b = temp = 6
print('a =',a,'b =',b)
》》》
a = 8 b = 6

在对一个元组解包时，变量的数量必须和元组中的元素要一一对应 ，如果出现变量和元素没有对等的情况下，我们可以在变量面前加一个* ，这样变量就会将获取元组中所有剩余的元素以列表的形式返回

my_tuple = 10,20,30,40
a,b,c,d = my_tuple
print(a,b)
》》》
10 20

my_tuple = 10,20,30,40,50,60
*a,b,c = my_tuple   # [10, 20, 30, 40] 50 60
a,*b,c = my_tuple   # 10 [20, 30, 40, 50] 60
a,b,*c = my_tuple   # 10 20 [30, 40, 50, 60]

print(a,b,c)

在这里怎么操作列表，就怎么操作元组

a,b,*c = [1,2,3,4,5,6,7]  #   1 2 [3, 4, 5, 6, 7]

a,b,*c = 'python java'     # p y ['t', 'h', 'o', 'n', ' ', 'j', 'a', 'v', 'a']

print(a,b,c)

02 - 对象 - 可变对象

每个对象在每个内存当中保存了三个数据
id(标识）
value（值）
列表据是一个可变对象 a = [1,2,3]
a[0] = 10 (改对象） 这个操作是通过修改变量去修改对象的值
a = [4，5，6] （改变量）
改变对象不会 使内存地址发生改变
改变变量 才会 使内存地址发生改变

这个操作是在给变量重新赋值，这种操作会改变变量指向的对象，一般只有在为变量赋值时才是修改变量，其余的都是在修改对象

改变对象不 使内存地址发生改变
a = [1,2,3]
print('修改前：',a,id(a))

# 通过索引来改变列表   内存地址是一样的
a[0] = 10
print('修改后：',a,id(a))
>>>
修改前： [1, 2, 3] 2199726601352
修改后： [10, 2, 3] 2199726601352

改变变量 会使 内存地址发生改变
# 为变量赋值
a = [4,5,6]
print('修改后：',a,id(a))
>>>
修改后： [4, 5, 6] 2199727447688



a = [1,2,3]
b = a
b[0] = 10
print('a',a,id(a))
print('b',b,id(b))
>>>
a [10, 2, 3] 2199726601352
b [10, 2, 3] 2199726601352
这个操作是在给变量重新赋值，这种操作会改变变量指向的对象，其内存地址一定会发生改变，一般只有在为变量赋值时才是修改变量，其余的都是在修改对象


案例一：
a = [1,2,3]
b = a
b = [1,2,3]
print('a',a,id(a))
print('b',b,id(b))
》》》
a [1, 2, 3] 1399834227848
b [1, 2, 3] 1399835074184

案例二：
a = [1,2,3]
print('修改前',a,id(a))
a = [1,2,3]
print('修改后',a,id(a))
修改前 [1, 2, 3] 1939110305544
修改后 [1, 2, 3] 1939109459080


**加粗样式**这个操作是在为变量重新赋值，虽然说重新赋值的这个值看起来和赋值之前的值没有什么差别，但是其内存地址发生了改变。

03. 序列 - == 和 is

3. == ，！= 和 is ， is not
   == 和 ！= 比较的是对象的值是否相等
   is 和 is not 比较的是对象的id是否相等 （比较两个对象是否是同于一个对象）

a = [1,2,3]
b = [1,2,3]
print(a,b)
print(id(a),id(b))
print(a==b)
print(a is b）

》》》[1, 2, 3] [1, 2, 3]
1558503634056 1558504480392
True
False

04 - 映射 - 字典简介

1.字典

字典属于一个新的数据结构，称之为映射(打开Python官网Welcome to Python.org——>Documentation——>Python 3.x Docs——>Library Reference——>Mapping Types - dict)
字典的作用和列表差不多，都是用来存储对象的容器

每一个元素都有一个名字，通过这个唯一的名字可以快熟查找到我要的元素
唯一的名字（key）通过key可以快速查询到 Value
key 不可变;value可变
所以提字典也成为 键值对（key-value）结构
每个字典当中有多个键值对，每个键值对称之为一项（item）

创建字典  dict
语法   {key:value,key:value,key:value}
d = {'name':'钢铁侠','age':30,'sex':'男'}    #   {'name': '钢铁侠', 'age':                                                30, 'sex': '男'} <class 'dict'>

字典的键可以是任意不可变对象(int,str,bool,key:value)
字典的值可以是任意对象
字典当中的键是不可以重复的,如果重复后边的会替换前边的
d = {'name':'钢铁侠','age':30,'sex':'男','name':'葫芦娃'}  
# {'name':'葫芦娃', 'age': 30, 'sex': '男'} <class 'dict'>

d = {
    'name':'钢铁侠',    #  有的人喜欢这样写 ,也可以
    'age':18,           # {'name': '钢铁侠', 'age': 18, 'sex': '男'} <class                            'dict'>
    'sex':'男'
}

可以根据键来获取值
print(d['name'],d['age'],d['sex'])  
>>>
钢铁侠 30 男

05 - 映射 - 字典的使用

使用dict()函数来创建字典

d = dict(name = '钢铁侠',age = 30,sex = '男')
print(d,type(d))
>>>
{'name': '钢铁侠', 'age': 30, 'sex': '男'} <class 'dict'>

# 可以将一个包含有双值子序列的序列转换为字典
# 双值序列,序列当中只有2个值  [1,2] ('b',6] 'de'
# 子序列, 如果序列当中的元素也是序列,那么我们称这个元素为子序列
# 例如:[(2,3),(7,8)]
# d = dict([('name','钢铁侠'),('age',18)])

# d = dict(name = '钢铁侠',age = 30,sex = '男')
# 获取字典当中的长度 len()
# print(len(d))   # 3

# in 检查字典当中是否包含指定的键
# not in 检查字典当中是否不包含指定的键
# print('Hello' in d)  # False

# 获取字典当中的值, 根据键来获取
# 语法 d[key]
# print(d['age'])   #  30

# w = 'name'
# print(d[w])   # 钢铁侠
# print(d.get('name'))  # 钢铁侠     get后面的括号里面填的是name,打印出来是 钢铁侠
# print(d.get('钢铁侠'))  # None      get后面填的是钢铁侠,        打印出来是  None
# print(d.get('python'))  # None

w = 'name'
# get(key[,deafult])
print(d.get('python','返回值'))    #   返回值
print(d.get('python','66'))           #   66

(1).修改字典, d[key] = value

d = dict(name = ‘钢铁侠’,age = 30,sex = ‘男’)

修改字典
d[key] = value
如果key值存在就覆盖,不存在就添加
d[‘name’] = ‘葫芦娃’ # {‘name’: ‘葫芦娃’, ‘age’: 30, ‘sex’: ‘男’}
print(d)

d[‘phone’] = ‘1,2,3,4,5,6’
print(d) # {‘name’: ‘葫芦娃’, ‘age’: 30, ‘sex’: ‘男’, ‘phone’: ‘1,2,3,4,5,6’}

(2).setdefault(key[,default]) 就是向字典中添加key-value

如果key已经存在字典中,则返回key的值,不会对字典做任何操作
如果key不存在,则向字典中添加这个key,并设置value
setdefault(key[key[,default])
d = dict(name = ‘钢铁侠’,age = 30,sex = ‘男’)
d.setdefault(‘name’,‘葫芦娃’)
print(d) # {‘name’: ‘钢铁侠’, ‘age’: 30, ‘sex’: ‘男’}

result = d.setdefault(‘python’,‘葫芦娃’)
print(result) # 葫芦娃
print(d) # {‘name’: ‘钢铁侠’, ‘age’: 30, ‘sex’: ‘男’, ‘python’: ‘葫芦娃’}

自主测试(注意:不要把setdefault写成了setfault)
result = d.setdefault(‘游戏名称’,‘葫芦娃’)
print(result) # 葫芦娃
print(d) # {‘name’: ‘钢铁侠’, ‘age’: 30, ‘sex’: ‘男’, ‘游戏名称’: ‘葫芦娃’}

(3).update(), 添加

update() 添加
将其他字典当中的key-value 添加到当前字典当中
如果有重复的key,则后边的会替换到前面的 a
d = {‘a’:1,‘b’:2,‘c’:3}
d2 = {‘d’:4,‘e’:5,‘f’:6}
d.update(d2)
print(d) # {‘a’: 1, ‘b’: 2, ‘c’: 3, ‘d’: 4, ‘e’: 5, ‘f’: 6}

d = {‘a’:1,‘b’:2,‘c’:3}
d2 = {‘d’:4,‘e’:5,‘f’:6,‘a’:7}
d.update(d2)
print(d) # {‘a’: 7, ‘b’: 2, ‘c’: 3, ‘d’: 4, ‘e’: 5, ‘f’: 6}

(4).del d[key] ,删除

d = {‘a’:1,‘b’:2,‘c’:3}
d2 = {‘d’:4,‘e’:5,‘f’:6,‘a’:7}
d.update(d2)
删除
del d[‘a’] # {‘b’: 2, ‘c’: 3, ‘d’: 4, ‘e’: 5, ‘f’: 6} a被删除掉了
del d[‘b’] # {‘c’: 3, ‘d’: 4, ‘e’: 5, ‘f’: 6} 紧接着 b 又被删除掉了
print(d)

(5).popitem() 随机删除字典当中的一个键值对,一般都会删除最后一个键值对

d.popitem() # {‘c’: 3, ‘d’: 4, ‘e’: 5}
result = d.popitem()
print(result) # (‘e’, 5) 删除的对象是: e
d.popitem() # {‘c’: 3, ‘d’: 4}
print(d)

(6).clear() 清空字典

clear() 清空字典
d.clear()
print(d) # {}

06 - 函数 - copy()

d = {'a':1,'b':2,'c':3}

d2 = d
print('d = ' ,d)    # d =  {'a': 1, 'b': 2, 'c': 3}
print('d2 = ',d2)   # d2 =  {'a': 1, 'b': 2, 'c': 3}

d['b'] = 10
print('d = ' ,d)   #  d =  {'a': 1, 'b': 10, 'c': 3}
print('d2 = ',d2)   #  d2 =  {'a': 1, 'b': 10, 'c': 3}

上面的操作不是复制,真正的复制是:复制后两个对象之间没有什么关系了,就算是改变其中一个键值对的value(值)时,对另一个对象中的键值对的value(值)没有什么影响猜对.

copy()函数应该是以下操作
copy()  该方法是用来对字典进行一个潜复制
复制以后的对象 ,和原对象就是对立 , 修改一个不会影响第二个
d = {'a':1,'b':2,'c':3}

d2 = d.copy()
print('d = ',d,id(d))  # d =  {'a': 1, 'b': 2, 'c': 3} 2241405152712
print('d2 = ',d2,id(d2))  # d2 =  {'a': 1, 'b': 2, 'c': 3} 2241405152280
以上两个的结果一样，对象不一样（即内存地址不一样），这个叫做复制

d = {'a':1,'b':2,'c':3}

d2 = d.copy()
d['a'] = 88
print('d = ',d,id(d))     # d =  {'a': 88, 'b': 2, 'c': 3} 1519759117912
print('d2 = ',d2,id(d2))  # d2 =  {'a': 1, 'b': 2, 'c': 3} 1519758240792

潜复制会简单复制对象内部的值,如果这个值也是一个可变对象,这个可变对象是不会被复制的(比如:d里面的这个值{'name':'钢铁侠','age':30}是不会被复制的
d = {'a':{'name':'钢铁侠','age':30},'b':2,'c':3}

d2 = d.copy()
print('d =',d,id(d)) # d = {'a': {'name': '钢铁侠', 'age': 30}, 'b': 2, 'c': 3} 2158889823328
print('d2 =',d2,id(d2)) # d2 = {'a': {'name': '钢铁侠', 'age': 30}, 'b': 2, 'c': 3} 2158889823688

07 - 映射 - 遍历字典

字典的遍历
keys()
values()
items()

(1).keys()

d = {‘name’:‘钢铁侠’,‘age’:30,‘sex’:‘男’}

通过遍历keys()来获取所有的键

for k in d.keys():
print(d[k]) # # 这个可以获取到key的值
,>>>钢铁侠
30
男

(2).values()

values()
for v in values():
print(v) # # 这个不能获取到key的值,只能获取到value的值,一般不用这个
,>>>钢铁侠
30
男

(3).items()

item()
该方法会返回字典中所有的项
它会返回一个序列,序列中包含有双值子序列
双值分别是 字典中的key 和 value
print(d.items()) # dict_items([(‘name’, ‘钢铁侠’), (‘age’, 30), (‘sex’, ‘男’)])

for k,v in d.items():
print(k,’=’,v)
,>>>
name = 钢铁侠
age = 30
sex = 男

08 - 映射 - 字典练习

练习:爬取喜马拉雅轻音乐的下载地址
import requests

import json

headers = {
    'User-Agent': 'Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/75.0.3770.142 Safari/537.36'
}
url = 'https://www.ximalaya.com/revision/play/album?albumId=291718&pageNum=1&sort=1&pageSize=30'

r = requests.get(url,headers=headers)
ret = r.text
result = json.loads(ret)
content_list = result['data']['tracksAudioPlay']
# print(ret,type(ret))

for content in content_list:
    print(content['src'])
    >>>打印出来的是一列以 http 为开头的轻音乐下载地址

a = '123'
a = "{'name':'python'}"
print(a,type(a))  # {'name':'python'} <class 'str'>

c = '{"name":"python"}'   # json类型的 字符串

a = {"name":"123","data":{"result":[{"src":"python1"},{"src":"python2"},{"src":"python3"}]}}

b = a['data']  # {"result":[{"src":"python1"},{"src":"python2"},{"src":"python3"}]}

c = b['result'] # [{"src":"python1"},{"src":"python2"},{"src":"python3"}]

for i in c:
    print(i['src'])
# python1
# python2
# python3