python第八课 元组&字典

一、元组的简介使用

元组 表现形式：tuple
元组是一个不可变序列
当我们希望这个数据不变的时候我们就用元组，其余情况用列表

#创建一个元组
my_tuple = (1,2,3,4)
print(my_tuple,type(my_tuple))

>>> (1, 2, 3, 4) <class 'tuple'>

使用其他方法创建元组

var = 10
print(type(var))
var1 = 10, 
print(type(var1))

>>> <class 'int'>
>>> <class 'tuple'>

解包

解包：即将元组中的每一个元素赋值给一个变量

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

>>> 10 20 30 40

当变量和元组中的值不一致时，可以使用*将剩余变量将以剩下的变量以列表的形式进行返回

var2 = 10, 20, 30, 40
a, b, *c = var2
print(a, b, c)
a, *b, c = var2
print(a, b, c)
*a, b, c = var2
print(a, b, c)

>>> 10 20 [30, 40]
>>> 10 [20, 30] 40
>>> [10, 20] 30 40

二、可变对象

对一个变量进行储存时，会保存下面三个
id()：内存所在的地址
type()：变量的数据类型
value()：变量是多少
对一个变量的进行赋值实际上是在更改变量的值,即对对象做出更改。如下代码所示：

a = [1, 2, 3]
print(a, id(a), type(a))
a[0] = 10            #改对象
print(a, id(a), type(a))
a = [4, 5, 6]        #改变量
print(a, id(a), type(a))

>>> [1, 2, 3] 2005102330120 <class 'list'>
>>> [10, 2, 3] 2005102330120 <class 'list'>
>>> [4, 5, 6] 2005102762376 <class 'list'>

如上代码所示，对对象进行更改不改变变量的内存地址，但是当对变量进行更改是，变量的内存地址会相应的进行改变。

在将一个变量赋值给另外一个变量时，是在做深度复制，会将id一起赋值给另外一个变量，此时如果更改其中一个变量的对象，两个变量都会改变，代码如下：

a = [1, 2, 3]
b = a
b[0] = 10
print(a, id(a))
print(b, id(b))

>>> [10, 2, 3] 2005102707848 
>>> [10, 2, 3] 2005102707848

如果想两个变量相对分离，需要使用.copy()或者直接重新定义。如：

#浅复制
a = [1, 2, 3]
b = a.copy()
b[0] = 10
print('a = ', a, '  a的地址是：', id(a))
print('b = ', b, ' b的地址是：', id(b))

#使用重新定义
a = [1, 2, 3]
b = [1, 2, 3]
b[0] = 10
print('a = ', a, '  a的地址是：', id(a))
print('b = ', b, ' b的地址是：', id(b))

>>> a =  [1, 2, 3]   a的地址是： 2005103536008
>>> b =  [10, 2, 3]  b的地址是： 2005103464328
>>> a =  [1, 2, 3]   a的地址是： 2005103460552
>>> b =  [10, 2, 3]  b的地址是： 2005103463944

三、 == 和 is

==是用来判断两个对象的值是否相等
is 是用来判断两个对象是不是同一个即id是不是同一个

a = [1, 2, 3]
b = [1, 2, 3]
print('a和b相等吗？ ', a == b)
print('a就是b吗？', a is b)

>>>a和b相等吗？  True
>>> a就是b吗？ False

四、字典

变现形式：dict
字典是一种新的 数据结构，称之为映射（mappin）
字典的作用就是用来储存对象的容器
列表存储数据性能很好，但是查询数据性能很差
字典中每个一个元素都有唯一的一个名字，通过这个名字可以快速查找到指定元素

创建一个字典

d ={
    'name' : '葫芦娃',
    'age' : '18'
}
print(d)

>>> {'name': '葫芦娃', 'age': '18'}

双值子序列

序列当中包含多个子序列，每个子序列都含有两个值。如下

d = {'name':'孙悟空','age':18,'gender':'男'}
print(d.items())

>>> dict_items([('name', '孙悟空'), ('age', 18), ('gender', '男')])

在上述代码中d本身是一个字典。当使用.items()函数进行访问时，会返回一个双值子序列
同样我们也可以通过定义一个双值子序列的方式来转换成一个字典

d = dict([('name', '葫芦娃'), ('age', '32')])#双值子序列
print(type(d))
print(d)
#或者使用赋值的方式
d = dict(name = '葫芦娃', age = '20',  gender = '男')
print(type(d))
print(d)

>>> <class 'dict'>
>>> {'name': '葫芦娃', 'age': '32'}
>>> <class 'dict'>
>>> {'name': '葫芦娃', 'age': '20', 'gender': '男'}

五、字典的使用

检查字典中时候含有一个某个元素

d = dict(name = '葫芦娃', age = '20',  gender = '男')
## in 检查字典当中是否包含指定的键
re = 'age' in d
print(re)
## not in 检查字典中是否不包含指定的键
re = 'name' not in d
print(re)

>>> True
>>> False

获取字典中的值

d = dict(name = '葫芦娃', age = '20',  gender = '男')
n = 'name'
print(d[n])
#或
#print(d['name'])
pp = d.get('name',100)#访问字典中的值，如果该元素不存在则赋值100
print(pp)

>>> 葫芦娃
>>> 葫芦娃

#访问字典中所有的键
print(d.keys())
#访问字典中所以的value
print(d.values())
#访问字典的全部元素
print(d.items())

>>> dict_keys(['name', 'age', 'gender'])
>>> dict_values(['葫芦娃', '20', '男'])
>>> dict_items([('name', '葫芦娃'), ('age', '20'), ('gender', '男')])

修改字典中的值

d = dict(name = '葫芦娃', age = '20',  gender = '男')
print(d)
d['name'] = '黑猫警长'
print(d)

>>> {'name': '葫芦娃', 'age': '20', 'gender': '男'}
>>> {'name': '黑猫警长', 'age': '20', 'gender': '男'}

字典的常用函数

d.setdefault()#添加键值对，有键则不更改，无则添加
d.update()#将两个字典拼接起来，如果有重复，括号中的覆盖原键值对
del() #删除字典
d.popitem()随机删除字典当中的一个键值对，一般情况下都会删除最后一个键值对（删除后会讲所删除的键值对返回）
pop(key[,default])：根据key删除字典当中的键值对 d.pop(“name”)#当key值不存在时，返回KeyError

d = dict(name = '葫芦娃', age = '20',  gender = '男')
d2 ={
    'arms_name': '天问',
    'number' : 'NO.1',
    'usr' : '秦始皇'
} 
d.setdefault('ability ', '力大无穷')
print(d)
d.update(d2)
print(d)
d.popitem()
print(d)
d.pop('gender')
print(d)
del(d)
# print(d)#此时打印报错d未定义

>>> {'name': '葫芦娃', 'age': '20', 'gender': '男', 'ability ': '力大无穷'}
>>> {'name': '葫芦娃', 'age': '20', 'gender': '男', 'ability ': '力大无穷', 'arms_name': '天问', 'number': 'NO.1', 'usr': '秦始皇'}
>>> {'name': '葫芦娃', 'age': '20', 'gender': '男', 'ability ': '力大无穷', 'arms_name': '天问', 'number': 'NO.1'}
>>> {'name': '葫芦娃', 'age': '20', 'ability ': '力大无穷', 'arms_name': '天问', 'number': 'NO.1'}

六、遍历字典

遍历字典通常使用下面三个函数
keys()：可以拿到所有的key值
values()：可以拿到所有的value值
iteams()：拿到一对键值对

dic = {
    'name' : '大娃',
    'age' : '18',
    'tell' : '12222'
    
}
#根据key值遍历字典
for k in dic.keys():
    print(dic[k])
#根据value值遍历字典
for v in dic.values():
    print(v)
#根据键值对
for k, v in dic.items():
    print(k,v)

-----根据key值------
>>> 大娃
>>> 18
>>> 12222
------根据value值------
>>> 大娃
>>> 18
>>> 12222
-------根据键值对-------
>>> name 大娃
>>> age 18
>>> tell 12222

七、字典练习

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

print(type(a))
import json
b = json.loads(a)
print(b, type(b))
c = b['data']
print(c, type(c))
d = c['result']
print(d, type(d))

i = 0
while(i < 3):
    e = d[i]
    print(e.values())
    i += 1
    

>>> <class 'str'>
>>> {'name': '123', 'data': {'result': [{'src': 'python1'}, {'src': 'python2'}, {'src': 'python3'}]}} <class 'dict'>
>>> {'result': [{'src': 'python1'}, {'src': 'python2'}, {'src': 'python3'}]} <class 'dict'>
>>> [{'src': 'python1'}, {'src': 'python2'}, {'src': 'python3'}] <class 'list'>
>>> dict_values(['python1'])
>>> dict_values(['python2'])
>>> dict_values(['python3'])