python基础-03-列表 | 元组 | 字典 | 集合

1 序列

概念

内存中存放多个值的连续空间
字符串、列表、元组、字典、集合
字符串即字符序列
列表即可存储任意类型的序列，列表中地址也是对象，第一个地址赋给变量

2 列表

a = [10, 20, 'abc', True]
# 列表方法查阅手册

列表大小可变
字符串即字符序列，字符串方法列表中基本也都有

创建

# []方式创建
a = [10,20,'Vincent', True]
a.append('Wu')

# list创建
a = list()
a = list(range(10))
a = list('Vincent','Wu')

# range创建，起始、结束、步长
a = list(3,15,2) 
# 倒序
a = list(3,15,-1)

# 推导式生成列表
# 2 4 6 8 10
a = [x*2 for x in range(5)]

# if过滤
a = [x*2 for x in range(100) if x%9==0]

元素增加

a = [10,20]
# 尽量避免中间位置元素的增加和删除
a.append(30)
# 直接拼接，产生新对象
a = a + [50]
# 扩展，不创建新对象
a.extend[50,60]
# 第2个位置插入100
a.insert(2,100)
# 乘法扩展，适用于乘法扩展的还有字符串、元组
b = a * 3

元素删除

# del删除
a = [10,20,30]
# 底层原理实际是数组的拷贝
del a[1]
# 删除并返回指定元素，未指定则返回最后一个元素
a.pop()
# 删除首次出现的指定元素
a.remove(10)

元素访问和计数

通过索引访问,超范围报错

index | count | len | in

# 从第3个元素开始搜索
a.index(20,3)
# 计数
a.count(20)
# 列表长度
len(a)
# 资格判断
20 in a

切片 - slice | 遍历

与字符串几乎一致，略

排序

a = [10,20,30]
# 排序，对象不变
a.sort()
a.sort(reverse=True)

随机排序

import random
random.shuffle(a)

建新列表的排序

b = sorted(a)
b = sorted(a,reverse=True
# 切片逆序
b = a[::-1]

迭代器

# 迭代器逆序
c = reversed(a)
list(c)

最大最小值

max(a)
min(a)

求和

sum(a)

多维列表

二维列表可存储表格信息

a  = [
  ['张三',18,'北京'],
  ['李四',19,'上海'],
  ['王五',20,'深圳']
]
# 打印
for i in range(3):
  for j in range(3):
    print(a[i][j], end='\t')
  print()

3 元组

概述

元组属于不可变序列
不能增删改元素，只需学习元组的创建和删除，访问和计数
其他操作与列表类似：
索引访问、切片、连接、成员关系操作、比较运算、计数长度最大值最小值

关于学习方法：
不要因为过于追求完美卡在一个点上
注重体系的建立

元组操作

# 创建元组，小括号可以省略
a = (10,20,30)
# 一个元素加逗号，不然解释器会认为是一个数
a = (10,)

b = tuple()
# 字符串转为元组
b = tuple('abc')
b = tuple(range(3))
b = tuple(1,2,3)

# 删除元组
del b

总结：
tuple()可以接收列表、字符串、其他序列类型、迭代器生成元组
list()可以接收元组等序列类型、迭代器类型生成列表

元素的访问 | 计数

# 定义一个元组
a = (10,20,30,3)
# 访问
a[1]
# 元组元素不能修改
# 其他元组操作与列表几乎一致
a = tuple('abcdefg')
# 切片生成元组
a[1:10]

# 列表对象不能调用sorted()方法
# 生成列表
sorted(a)

b = (1,2)
# +拼接生成新元组
a + b

# zip方法将多个元组封装为一个列表
d = zip(a,b)
list(d)

创建元组 - 生成器推导

生成器推导式生成一个生成器对象

s = (x*2 for x in range(5))
# 生成器对象创建元组
tuple(s)
# 生成器对象创建列表
# 只能访问一次元组，再访问为空
list(s)
# 移动指针，调用多次超范围后会抛异常
s.__next__()

总结：
元组的访问和处理速度比列表
与整数和字符串一样，元组可以作为字典的键，列表则不能作为字典的键

4 字典

概述

字典就是键值对无序可变序列
字典底层也是数组
键是任意不可变元素，不可重复
值也可以是列表对象等

# 创建一个字典
a = {'name':'Vincent','age':18,'job':'programmer'}
# 字典元素访问
a.get('name')

# 通过dict()创建
b = dict(name='Vincent',age=18)
# 空的字典对象
c = {}
# dict传入元组
d = dict(('name','Vincent'),(‘age’,18))

# 通过zip创建
k = ['name','age','job']
v = ['Vincent',18,'teacher']
dict(zip(k,v))
# 值为None，空
dict.fromkeys('name','age','job')

元素访问

a = {'name':'Vincent','age':18,'job':'programmer'}
a['name']
a['age']
# 访问的键不存在会报错
# 推荐通过get方式获取，优点是键不存在返回None不会报异常
a.get('name')
# 返回None
a.get('nonekey')

# 列出所有键值对
a.items()
# 列出所有的键
a.keys()
# 列出所有的值
a.values()
# 有多少键值对
a.len()
# 键是否在字典中
‘name’ in a

元素添加 | 修改 | 删除

# 新加键值对，键已存在会覆盖
a['address'] = '上地'
# b所有键值对添加到a字典对象上，如果key有重复则覆盖
a.update(b)

del(a['name'])
# 删除所有键值对
a.clear()
# 删除指定的键，返回对应的值对象
a.pop('age')
# 随机删除并返回该键值对，字典是无序的没有最后一个的概念
a.popitem()

序列解包

序列解包可以方便地给多个变量赋值

x,y,z = (10,20,30)
(x,y,z) = (10,20,30)
[x,y,z] = [10,20,30]

# 序列解包用于字典
s = {'name':'Vincent','age':18,'job':'teacher'}
# 默认对键进行操作
name,age,job = s
# 对键值进行操作
name,age,job = s.items()
# 对值进行操作
name,age,job = s.values()

练习

列表字典表示表格数据
表格数据

姓名  年龄  薪资  城市
张三  18  30000  北京
李四  19  20000  上海
王五  20  10000   深圳

代码

r1 = {'name':'张三','age':18,'salary':30000,'city':'北京'}
r2 = {'name':'李四','age':19,'salary':20000,'city':'上海'}
r3 = {'name':'王五','age':20,'salary':10000,'city':'深圳'}
tb = [r1,r2,r3]

# 获取李四薪资
print(tb[1].get('salary'))
# 循环获取所有人薪资
for i in range(len(tb)):
  print(tb[i].get('salary'))

# 打印表格所有数据
for i in range(len(tb)):
  keys = tb.keys()
  for key in keys:
    print(tb[i].get(key), end='\t')

所有数据都可以用表格表示

字典底层原理

字典对象核心是散列表
散列表是一个稀疏数组(总是有空白元素的数组)
数组的单元叫bucket，每个bucket由键的引用和值的引用组成
每个bucket偏移量一致
key是可计算hash值的对象

过程分析: a['name'] = 'Vincent'
1.计算name的hash值
hash(name)
bin(hash(name))
2.拿计算出散列值最后3位作为偏移量，看对应偏移量的bucket是否为空，如果空则放入，如果非空则再往左取3位作为偏移量，直到放入位置
3.数组3分之2已满，数组就会自动扩容

如何根据键查询值

字典取值过程:
1.计算散列值
bin(hash('name'))
2.假设数组长度为8，取后3位对应的偏移量的值
3.如果非空则取出，如果为空则往左取3位

添加数据可能导致字典扩容，先遍历再修改
字典内存开销巨大，空间换时间

5 集合 - 交 | 并 | 差

集合无序可变，元素不能重复
集合底层就是字典，集合所有元素都是字典的键对象

# 定义一个集合
a = {3,5,7}
# 添加元素
a.add(9)
# 列表转为集合
b = ['a','b','c']
c = set(b)
# 删除元素
c.remove('a')
# 并集
a|b
# 交集
a&b
# 差集
a-b
# 交集
a.intersection(b)
# 并集
a.union(b)
# 差集
a.difference(b)