字典的常用方法及使用

1.今日内容大纲

1. 列表
2. 基础数据类型dict
3. 基础数据类型字典
4. 字典的常用操作方法

2.具体内容

1.列表

• 列表

  l1 = [1,2,3]
  
  l2 = list('abc')
  
  l3 = [i for i in range(10)]
  
  

• 列表的增删改查

  # 增 
  append 追加；insert 插入； extend 迭代着追加
  # 删
  pop 按照索引删除，有返回值； remove 按照元素删除；
  del 按照索引 切片 删除列表； clear 清空。
  # 改：
  l1[0] = 按照索引改值
  l1[1:3] =  按照切片改值。
  l1[::2] = 按照步长更改。
  # 查：
  索引查询，切片查，for循环。
  
  l1 + l1 列表可以相加
  l1*int相乘。)
  

2.基础数据类型元组

• 引子

  程序中，有时候需要将一些重要的数据放在一个容器型数据类型中，只允许看，不允许改。我们应该讲这些数据放在元组中。

• 创建方式

  tu = (1,2,3,'太白')
  tu1 = tuple('abcd')
  print(tu1)
  

• 数据类型的分类

  容器型： list,tuple,dict,set

  非容器型:int str bool

  可变的数据类型：list，dict，set

  不可变的数据类型：int bool str tuple

• 元组只能查看：索引，切片，for循环。

  tu = (1,2,3,'太白')
  print(tu[0])
  print(tu[::2])
  for i in tu:
      print(i)
  

• 坑1：如果元组中只有一个元素并且没有逗号，则它不是元组与该元素类型一致。

  tu1 = ('barry')
  tu1 = (100)
  tu1 = (100,)
  print(tu1,type(tu1)
  

• 坑2：元组是不可变的，直接属于元组的元素不可遍，如果元组中还嵌套其他可变的数据类型，那么这些数据类型里面的元素是可变的。

  # tu1 = (22, 33, ['barry', '冲哥'])
  # # del tu1[-1]  不行
  # tu1[-1].append(666)
  # print(tu1)
  

3.基础数据类型字典

• 引子

  列表的缺点：

  1. 查询速度慢。

     l1 = [上百万的元素]
     if '冲哥' in l1:  # 遍历查询，速度慢
     	pass
     

  2. 列表存储的数据与数据之间的关联性不凸显。

     l1 = ['达哥', 20, '男', '看电影', '冲哥', 18, '男', '打游戏']
     

  数据类型中，有一个容器型数据类型：dict，字典是以键值对的形式存储的，字典的键是唯一的，键是不可变的数据类型。字典的值是任意数据类型。

  python3.5版本之前，字典是无序的。python3.6之后，字典是按照创建字典时插入的数据排列的。

  字典的优点：

  1. 查询速度快。

     直接找到key去进行查询。

  2. 存储关联型的数据。

     dic = {'大哥': {'age': 18, 'hobby': '看电影'}}
     

  字典的缺点：

  字典是通过空间换取时间，具体的量级：几百万个对象，8GB 的内存没有问题。

• 创建字典的几种方式：

  d1 = {'name': 'barry'}
  
  d1 = dict(one=1, two=2, name=123)
  # print(d1)
  
  d1 = dict((('n',111),('m',666),('q',222)))
  print(d1)
  
  dic = dict({'one': 1, 'two': 2, 'three': 3})
  print(dic)  # {'one': 1, 'two': 2, 'three': 3}
  

5.字典的常用操作方法

• 增

  # 增
  # 直接按照键去增加  有则改之，无则增加
  # d1['hobby'] = '乒乓球'
  # d1['age'] = 21
  # setdeafult 有返回值 有则不变，无则增加
  # d1.setdefault('hobby')
  # res = d1.setdefault('hobby','球类运动')
  # print(res)
  # d1.setdefault('age', 25)
  # print(d1)
  
  # 删
  # 按照键删除
  # res = d1.pop('name')
  # print(res)
  # res = d1.pop('name1',None)
  # print(res)
  
  # del d1['name']
  # del d1['name1']  # 报错
  
  # 清空
  # d1.clear()
  # print(d1)
  
  # 改
  # d1['age'] = 21
  # update更新 约等于 改
  # d1.update(hobby='球类')
  # d1.update(name='大哥')
  # print(d1)
  # dic1 = {"name":"jin","age":18,"sex":"male"}
  # dic2 = {"name":"alex","weight":75}
  # 将dic2中的键值对覆盖增加到dic1中
  # dic1.update(dic2)
  # print(dic1)
  # print(dic2)
  
  # 查
  # 直接按照键去查询
  # print(d1['name'])
  # print(d1['name1'])
  # get
  # print(d1.get('name'))
  # print(d1.get('name1'))
  # print(d1.get('name1','查啥？没有！'))
  
  # 字典提供了三种特殊的查询方法，返回的都是类似于列表的容器
  # print(d1.keys())  # 获取字典所有的键
  # print(d1.values())  # 获取字典所有的值
  # print(d1.items())  # 获取字典所有的键值对
  
  # 拆包 分别赋值
  # # a,b = (11,22)
  # # a,b = ['abc', 'dbe']
  # a,b = '太白', 'barry'
  # print(a,b)
  
  # 面试题：
  # a = 10
  # b = 20
  # a, b = b, a
  # print(a,b)
  
  # for 循环
  d1 = {'name': 'barry', 'age': 18}
  # for i in d1:
  #     print(i)
  
  # for key in d1.keys():
  #     print(key)
  
  # for value in d1.values():
  #     print(value)
  
  # for i in d1.items():
  #     print(i)
  
  # for k,v in d1.items():
  #     print(k,v)
  
  # 字典的嵌套
  dic = {
      'name':'汪峰',
      'age':48,
      'wife':[{'name':'国际章','age':38}],
      'children':{'girl_first':'小苹果','girl_second':'小怡','girl_three':'顶顶'}
  }
  print(dic['children']['girl_three'])
  dic['children']['girl_three'] = '汪顶顶'
  print(dic)