Python基础课第八节课记录---Python数据结构-元组和字典

1. 元组

1.1 元组的基本简介

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

1.2 创建元组

1. 用()创建元组

my_tuple = (1, 2, 3, 4, 5)
print(my_tuple[3])
# 4
my_tuple[3] = 10
print(my_tuple)
# 报错 
my_tuple = (1,)
print(my_tuple)
# (1,)

如果元组不是空的元组，它里面至少得有一个逗号。
2. 不用()创建元组

my_tuple = 1, 2, 3, 4
print(my_tuple)
# (1, 2, 3, 4)

3. 用tuple()创建

my_tuple = tuple('Python')
print(my_tuple)
# ('P', 'y', 't', 'h', 'o', 'n')

1.3 元组的解包

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

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
a, b = b, a
print('a =', a)
print('b =', b)
# a = 8
# b = 6

在对一个元组进行解包时，变量的数量要和元组中元素保持一致当变量和元组当中的数量不一致时，我们可以在变量前面添加一个*,这样变量将会获取元组中剩余的元素不能加两个*

my_tuple = 10, 20, 30, 40
a, b, *c = my_tuple 
print(a, b, c)
# 10 20 [30, 40]
print(a, b, *c)
# 10 20 30 40
a, *b, c = my_tuple 
print(a, b, c)  
# 10 [20, 30] 40
*a, b, c = my_tuple 
print(a, b, c)   
# [10, 20] 30 40

2. 可变对象

每个对象当中保存了3个数据
id标识
type类型
value值

a = [1, 2, 3]
print('修改前:', a, id(a))
修改前: [1, 2, 3] 1918582739656
a[0] = 10 
print('修改后:', a, id(a))
修改后: [10, 2, 3] 1918582739656

这个操作是通过变量修改对象里面的值，这种操作不会改变变量指向的对象

a = [1, 2, 3]
print('修改前:', a, id(a))
修改前: [1, 2, 3] 1588024726216
a = [4, 5, 6] 
print('修改后:', a, id(a))
修改后: [4, 5, 6] 1588023875144

这个操作是在给变量重新赋值，这种操作会改变变量所指向的对象

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

这里的a和b指向同一个对象

==和is !=和is not
== != 比较的是对象的值是否相等
is 和 is not 比较的是对象的id是否相等

a = [1, 2, 3]
b = [1, 2, 3]
print(a, b)
# [1, 2, 3] [1, 2, 3]
print(id(a), id(b))
# 2442017788616 2442016937544
print(a is b)
# False
print(a == b)
# True

3. 字典

3.1 字典简介

表现形式：dict
字典是一种新的数据结构，称之为映射(mapping)
字典的作用就是用来存储对象的容器
列表存储数据性能很好，但是查询数据性能很差，字典中每一个元素都有唯一的一个名字，通过这个名字可以快速查找到指定的元素
唯一的名字称之为键(key)，通过Key可以查找到value,称之为键(value)，所以字典我们也称之为键值对(key-value)，每个字典可以有多个键值对，每个一个键值对我们称之为一项(item)

3.2 创建字典

1. 用{}创建字典
   语法：{key:value,key:value…}
   在字典当中键和值可以是哪些内容？
   值可以是任意对象
   键可以是任意不可变的对象(int,str,bool,tuple…)
   字典的键是不能重复的，如果出现重复后面的会替换前面的

d = {
	'name':'葫芦娃',
	'age':20,
	'gender':'男',
	'name':'钢铁侠'
}
print(d)
# {'name': '钢铁侠', 'age': 20, 'gender': '男'}
print(d['name'], d['age'], d['gender'])
# 钢铁侠 20 男

2. 用dict()函数来创建字典
   dict()这个函数可以将一个包含有双值子序列转换成字典
   双值序列：序列中只有2个值 [3,4] (‘name’,‘hello’) ‘xy’
   子序列：如果序列当中的元素也是序列，那么我们就称之为这个元素为子序列[(1,2)]

d = dict(name = '葫芦娃',age = 20,gender = '男')
print(d)
# {'name': '葫芦娃', 'age': 20, 'gender': '男'}
d = dict([('name','葫芦娃'),('age',18)])
print(d)
# {'name': '葫芦娃', 'age': 18}

3.3 字典的使用

len() 长度(获取字典当中键值对的个数)
in 检查字典当中是否包含指定的键
d[key] 获取字典里面的值
get(key[,default]) 根据键来获取字典当中的值，获取的键不存在，会返回None

d = dict([('name', '杰哥'), ('age', '19'), ('habit', 'Python')])
print(len(d))
# 3
print('age' in d)
# True
print(d['habit'])
# Python
print(d.get('Python', '没有这个键'))
# 没有这个键

3.4 修改字典

d[key] = value 如果存在则覆盖，不存在则添加
d.setdefault(key[,default]) 可以用来向字典当中添加键值对，如果key已经存在字典当中，则返回key的值，不会对字典做任何操作，如果key不存在，则向字典当中添加这个key，并设置value
update() 将其他的字典当中键值对添加到当中的字典当中
del() 删除
d.popitem() 随机删除字典当中的一个键值对，一般情况下都会删除最后一个键值对，删除之后它会将该键值对作为返回值返回
pop(key[,default]) 根据key删除字典当中的键值对key-value，返回的是删除的value值，如果删除不存在的Key,会抛出异常，如果指定了默认值，删除不存在的key值的时候，就会返回默认值

d = dict([('name', '杰哥'), ('age', '19')])
d['gender'] = '男'
print(d)
# {'name': '杰哥', 'age': '19', 'gender': '男'}
print(d.setdefault('habit', 'Python'))
print(d)
# Python
# {'name': '杰哥', 'age': '19', 'gender': '男', 'habit': 'Python'}
del d['habit']
print(d)
# {'name': '杰哥', 'age': '19', 'gender': '男'}
print(d.popitem())
print(d)
# ('gender', '男')
# {'name': '杰哥', 'age': '19'}
print(d.pop('name'))
print(d)
# 杰哥
# {'age': '19'}

4. 浅复制(浅拷贝)

只会复制字典本身，如果字典当中还有字典是不会被复制的
copy() 用于对字典进行一个浅复制

d = {'a': 1, 'b': 2, 'c': 3}
d2 = d.copy()
d['a'] = 1000
print('d = ', d, id(d))
# d =  {'a': 1000, 'b': 2, 'c': 3} 2649146354856
print('d2 =', d2, id(d2))
# d2 = {'a': 1, 'b': 2, 'c': 3} 2649146354928
d = {'a': {'name': '葫芦娃', 'age': 20}, 'b': 2, 'c': 3}
d2 = d.copy()
d2['a']['name'] = '黑猫警长'
print('d = ', d, id(d))
# d =  {'a': {'name': '黑猫警长', 'age': 20}, 'b': 2, 'c': 3} 2450158218480
print('d2 =', d2, id(d2))
# d2 = {'a': {'name': '黑猫警长', 'age': 20}, 'b': 2, 'c': 3} 2450158218840

5. 遍历字典

keys() 该方法会返回字典所有的键

d = {'name': '葫芦娃', 'age': 20, 'phone': '13246'}
print(d.keys())
# dict_keys(['name', 'age', 'phone'])
for k in d.keys():
    print(d[k])
# 葫芦娃
# 20
# 13246

values() 返回一个序列 序列中保存字典的值

d = {'name': '葫芦娃', 'age': 20, 'phone': '13246'}
print(d.values())
# dict_values(['葫芦娃', 20, '13246'])
for v in d.values():
    print(v)
# 葫芦娃
# 20
# 13246

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

d = {'name': '葫芦娃', 'age': 20, 'phone': '13246'}
print(d.items())
# dict_items([('name', '葫芦娃'), ('age', 20), ('phone', '13246')])
for k, v in d.items():
    print(k, '=', v)
# name = 葫芦娃
# age = 20
# phone = 13246

6. 练习

import json
a = '{"name":"123","data":{"result":[{"src":"python1"},{"src":"python2"},{"src":"python3"}]}}'
b = json.loads(a)
c = b['data']
d = c['result']
for i in d:
    print(i['src'])
# python1
# python2
# python3

7. 小结

通过这堂课的学习，元组和字典算是有了一个初步的认识，虽然课上只是有一个模糊的印象，但是课后的整理笔记却是一个复习的好方法，对那些方法有了记忆，我也在电脑上面操作了一番，对老师在课上的那些代码又独立的敲了一遍，加深了自己的印象。与此同时，这堂课还说了对象，对对象有了一个初步的认识，虽然还不是特别的理解，只能理解一些简单的对象，所以今后还要更加的继续努力，加油！