6.数据容器

1.数据容器
list 列表
tuple 元组
str 字符串
set 集合
dict 字典
2.列表
定义:[元素1,元素2,元素3]
里面元素的类型没有限制
定义一个空列表: a = []或者 a = list()
列表是有序的,允许元素重复
列表是可变的
2.1列表的下标
与字符串相似,方向从前向后.
最后一个元素下标为-1,从后向前依次递减
在嵌套的列表中,取出的下标对应的是整体
2.2列表的切片
内容连续,有序的容器类型都可以使用切片.
切片是从一个序列中获取子序列的方法,返回的是一个新的序列对象.
切片的操作是浅拷贝
操作:[开始下标:结束下标:步长]

import math

lst = [0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10]

k = 3
length = len(lst)
cnt = math.ceil(length/k)
for i in range(cnt):
    new_list = lst[i*k:k*(i+1)]
    print(new_list)

2.3列表的常用方法
查询某元素的下标: list.index()

print(lst.index(3))

修改指定位置元素的值: 列表[下标] = 值

lst[2] = 6
print(lst)

在列表中添加元素,追加到列表的尾部.list.append(元素)
在列表中插入元素,list.insert(‘下标’,value)
合并列表: list1.extend(list2) 追加到列表尾部
list1 += list2 也可以
删除指定下标的元素: del list[下标] 列表.pop(下标)不写默认最后一个.
删除某元素在列表中的第一个匹配项: list.remove(元素)
清空列表: list.clear()
统计列表内元素的数量: list.count(元素)
统计列表内元素的和(列表内元素是数字类型的): sum(list)
将列表转换成字符串:“分隔符”.join(list)跟split相对应
2.4列表的反转和排序
反转
list.reverse() reversed()返回的是一个反转后的迭代器

lst.reverse()
print(lst)

排序
sort list.sort(reverse=bool)reverse控制升序降序,默认是升序False,修改原列表
sorted 返回一个排序后的序列reverse控制升序降序,默认是升序False,返回一个新的列表
new_list = sorted(list)
sort,sorted可以指定key进行排序
2.5列表的遍历
for和while遍历
枚举

i = 0
length = len(lst)
while i < length:
    print(i, lst[i])
    i += 1

for i in enumerate(lst):
    print(i)

2.6列表推导式
快速构建列表的方式
[expression for item in iterable if condition]
expression 表达式
item 迭代器
iterable 要迭代的对象
condition(可选) 过滤列表中元素的条件
生成1-10的数字

lst = [x for x in range(1, 11)]

生成1-10的平方数

lst = [x**2 for x in range(1, 11)]

列表推导式的嵌套

print('\n'.join(['\t'.join([f"{j}x{i}={j*i}"for j in range(1, i+1)])for i in range(1,10)]))

2.7列表中的坑
移除元素时列表的长度会改变,可能会导致跳过某些元素
3.元组定义
与列表相似,中括号变成()
定义元组: a = (元素1,元素2)
定义空元素:a = () a = tuple()
定义单个元素:a = (元素,)
嵌套:变量名=((元素1,元素2),(元素3,元素4))
3.1元组的下标索引和切片
元组是不可变的
切片语法:元组[开始下标:结束下标:步长]
3.2元组的常用操作:
查找下标index(元素)
统计某个元素的个数:count()
统计元组元素的总数 len()
统计元组内元素的和(时数字类型): sum(元组)
元组和列表的相互转换: list() tuple()
3.3元组的不可变
安全
可以作为字典的键
可以作为函数参数

4.字典
字典的作用是通过部首或者拼音快速定位到对应的字词.
定义:
key ,唯一不可变 列表是可变的
value

dic = {
    'name': 'xxx',
    'age': 'xxx'
}

创建空字典: dic = {} dic = dict()

key_value = [('name', 'xxx'),('age', 'xxxx')]
print(dict(key_value))

fromkeys定义字典

dic = {}.fromkeys(['name', 'age'],'xxx')

出现相同key的值value会被覆盖掉
4.2字典的嵌套和取值

dic = {
    '小王':{
        '工资':100
    },
    '小李':{
        '工资': 200
    },
    '小张': {
        '工资': 100
    }
}
print(dic)
xiaowang_money = dic['小王']['工资']
print(xiaowang_money)
xiaowang_look = dic['小王'].get('长相')
print(xiaowang_look)

get()没有会返回None,前者会报错
get(key,定义value)如果取不到会返回定义的
4.3字典的常用操作
增加dict[key] = value,往字典里面增加新元素
修改 dict[key] = value,将key的value进行修改
删除 dict.pop(key) 能拿到删除的值
del dict[key]
dict.clear()
获取字典内所有的键: dict.keys()
获取字典内所有的value: dict.values()
把字典2里面的键值对更新到字典1里面: dict.update(dict2)
获取(键,值)元组数组: dict.items()
字典的遍历:
遍历所有key
遍历所有的value
遍历字典的key和value

dic = {
    'name': 'xxx',
    'age': 'xx',
    'look': 'x'
}
keys = dic.keys()
for key in keys:
    print(key)
#二者相同
for i in dic:
	print(i)


vals = dic.values()
for val in vals:
    print(val)


for key, value in dic.items():
    print(key, value)

4.4字典推导式
与列表相似

dic = {'1': 'a', 
       '2': 'b',
       '3': 'c'
       }
dic2 ={key:value.upper() for key, value in dic.items()}
print(dic2)

a_list = ['a', 'b', 'c']
dic = {index: val for index, val in enumerate(a_list)}
print(dic)

5.集合
需要一个数据集,且不允许重复
集合的特点:
可以容纳多个元素
可以容纳不同类型的元素
无序
不允许重复元素
可变
a = {元素1,元素2,元素3}
a = set()
集合不存在嵌套这一个东西
5.2集合的常用操作
添加新元素:set.add(元素),将指定元素添加进去
删除元素:set.remove(元素),将指定元素删除.
从集合中随机取出元素: set.pop(),有返回值
从集合中删除一个元素,set.discard(元素) 如果该元素不存在,则什么也不做
清空集合: set.clear()
set1.difference(set2),取出集合1有集合2没有的元素,生成一个新集合,集合1与集合2不变.
set1.difference_update(set2)消除jihe1里面集合2没有的元素,消除两个集合的差集,在原集合上面操作
set.union(set2)集合1与集合2的合并
set.intersection(set1)两个集合的交集
set1.issubset(集合2):判断集合1是否是集合二的子集,是的化返回True
set1.isdisjoint(set2)判断集合1和集合2是否包含相同的元素,包含返回False
len(set1):返回集合中元素的个数