Python元组和字典

元组tuple

创建

元组不可修改（指的是子对象的id），是一个序列，可以看成稳固版列表
可以用len获取长度，可以进行索引获取值
可以用()来表示，若元组只有1个项目，需要用，分割表示

>>> a=([1,2,3])
>>> type(a)
<class 'list'>
>>> a=([1,2,3],)
>>> type(a)
<class 'tuple'>
#元组中的列表元素是可以修改的
>>> a[0][0]=2
>>> a
([2, 2, 3],)
>>> a[0].insert(0,3)
>>> a
([3, 2, 2, 3],)
>>> 

元组解包

• 将对应元组的值赋值给对应的变量。
• 若当变量和元组当中的数量不一致时，我们可以在变量前面添加一个*,这样变量将会获取元组中剩余的元素,以列表形式存储元素值
• 不能有两个*
• 序列都有解包的特性，字符串，列表，元组

my_tuple = (1,2,3,4,5,)
a,b,*c=my_tuple
print(a) #1
print(b) #2
print(c) #[3,4,5]

常用方法

T.count(value) -> integer -- return number of occurrences of value
T.index(value, [start, [stop]]) -> integer -- return first index of value.
        Raises ValueError if the value is not present.

可变对象

每个对象在内存中保存3个数据id,type,value

• 第一种情况是is操作，直接让对象相等，用a=b表示
  is，is not用来判断2个变量id是否相等
• 第二种情况是不同对象，但value值相等，可以用a==b表示
  ==和!=用来判断变量value值是否相等

>>> a = [1,2,3]
>>> b = [1,2,3]
>>> id(a),id(b)
(1985127536200, 1985127586248)
>>> c = b
>>> id(a),id(b),id(c)
(1985127536200, 1985127586248, 1985127586248)
>>> c[0]= 10
>>> b
[10, 2, 3]

字典dict

创建

d =｛key:value,‘键’:‘值’｝
key不能修改，不能重复
value可修改，可以是重复的
一个键值对为一个item
dict() 双值子序列转换成字典

>>> a = {'key':123,'key':456}
>>> a
{'key': 456}#如果key一样，后面的重复key键值对覆盖了前面的key键值对

dict() -> new empty dictionary
dict(mapping) -> new dictionary initialized from a mapping object's
    (key, value) pairs
dict(iterable) -> new dictionary initialized as if via:
    d = {}
    for k, v in iterable:
        d[k] = v
dict(**kwargs)

使用

dict（对象） 		强制转换
len（D）			获取长度
对象 in D		判断是否有对应key值，print('hello' in d)
not in 			判断不包含key
D[key]			获取value
D[key]=value	修改value，若不存在，则添加
del d2['a']		删除

常用方法

D.clear() -> None.  Remove all items from D
D.copy() -> a shallow copy of D #浅复制
D.get(k[,d]) -> D[k] if k in D, else d.  d defaults to None
#获取key对应的value，若key不存在，返回d值，d值默认空
D.items() -> a set-like object providing a view on D's items
D.keys() -> a set-like object providing a view on D's keys
D.values() -> an object providing a view on D's values
D.pop(k[,d]) -> v, remove specified key and return the corresponding value.
        If key is not found, d is returned if given, otherwise KeyError is raised
D.popitem() -> (k, v), remove and return some (key, value) pair as a
        2-tuple; but raise KeyError if D is empty.
        #随机删除字典中的一个项，一般是最后一个项
D.setdefault(k[,d]) -> D.get(k,d), also set D[k]=d if k not in D
#获取k的value值，若不存在，则添加d[k]=d键值对
D.update([E, ]**F) -> None.  Update D from dict/iterable E and F.
        If E is present and has a .keys() method, then does:  for k in E: D[k] = E[k]
        If E is present and lacks a .keys() method, then does:  for k, v in E: D[k] = v
        In either case, this is followed by: for k in F:  D[k] = F[k]

浅复制

针对有嵌套的对象，浅复制对嵌套的对象直接引用，当改变嵌套对象中的值，复制的对象的值也会改变

• 改变外部键，不会影响另外一个对象
• 改变嵌套中的键，会同步嵌套内容至另外一个对象

>>> a = {1:10,2:20,3:{10:100,20:200}}
>>> b = a.copy()
>>> id(a),id(b)
(1985127143824, 1985127144832)
>>> a[3][10]=1000#改变嵌套内部的键，会同步嵌套内容至另外一个对象
>>> a
{1: 10, 2: 20, 3: {10: 1000, 20: 200}}
>>> b
{1: 10, 2: 20, 3: {10: 1000, 20: 200}}
>>> a[1]=100   #改变嵌套外部的键，不影响另外的对象
>>> a
{1: 100, 2: 20, 3: {10: 1000, 20: 200}}
>>> b
{1: 10, 2: 20, 3: {10: 1000, 20: 200}}

遍历字典

D.keys()    返回所有键
D.values()  返回所有值
D.items()   返回键值对
>>> for k,v in a.items():
	print(k,':',v)	
1 : 100
2 : 20
3 : {10: 1000, 20: 200}

字典练习

获取音频播放地址，可自行去找json文件练习。

import json
f_path = 'F:/python文档/ximalaya.json'
with open(f_path,'r',encoding='gbk') as f:
    data_dic = json.load(f)  #将json文件转换成Python字典
    # print(data_dic)
target = []
for src in data_dic['data']['tracksAudioPlay']:
    target.append(src['src'])
print(target)