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
  1. 列表存储的数据与数据之间的关联性不凸显。
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)