第六章 容器

容器

变量–单一数据
容器–存储多个数据，提供了一些操作数据的方法

  • 列表list
  • 字典dict
  • 元祖tuple
  • 集合set

列表list

特点：

元素的数据类型是不受限制的，可变长，有索引，有序，

可重复 参考动态数组

创建

# 创建：
# 1.用[]
# 可以存放各种类型的数据，一般情况下建议放同种类型数据
lst = [1, 2, 3, 4, 5, 'hello']
print(lst, type(lst))
lst2 = [] #空列表
print(lst2, bool(lst2))
# 2.list()内置函数
lst3 = list([10, 20, 30])
print(lst3, type(lst3))
# 3.列表生成式
lst4 = [i for i in range(1,11)]
print(lst4)

获取元素

# 列表是有索引的：正向索引：[0，len-1] 负向索引：[-len,-1]
# list index out of range 索引越界
lst =[10,20,30,40,50,60]
print(lst[0])
print(lst[-1])

# 获取多个元素：切片 列表名[start:end:step]
# start 起始索引，默认值0
# end 结束索引，默认值len
# 切片范围：[start,end）
# 切片的结果是复制，不影响原列表
# step 步长，可以省略，默认为1
print('------切片-------')
lst2=lst[0:2]
print(lst2)
# 遍历 for in 循环不能修改
for i in lst:
    print(i)
print('-----for in--------')
index = 0
while index < len(lst):
    print(lst[index])
    index+=1
print('------while-------')
index = 0
while index < len(lst):
    lst[index]=0
    print(lst[index])
    index+=1
print('------enumerate()可以遍历出索引和值-------')
for index,value in enumerate(lst):
    print(index,value)
#根据元素，查找索引位置
# 列表名，.index(查找的元素) 返回第一个找到的元素位置，找不到就报错
lst = [1,2,3,4,5]
print(lst.index(1))

判断元素

# in/not in判断某个元素是否在列表中
print(10 in lst)
print(10 not in lst)

添加元素

# 添加
# 添加单个元素
# append()在末尾追加
lst = [1,2,3,4,5]
print(lst,id(lst))
lst.append(0)
print(lst,id(lst))
# insert(index,ele)插入,索引太大直接加到末尾
lst.insert(1,0)
print(lst)
# 添加多个元素
# 列表的合并
lst2 =[55,44,33,22,11]
lst =lst+lst2
print(lst)
# extend 扩展，合并
lst.extend(lst2)
print(lst)
# 切片
lst[0:1]=[11,22,33]
print(lst)

修改元素

# 修改
# 修改单个元素
lst = [1,2,3,4,5]
lst[1]=90
print(lst)
# 修改多个值：切片
lst[4:]=[8,23,15]
print(lst)

删除元素

# 删除
# 删除单个元素
# remove(ele)按对象
lst = [11,22,33,44,55]
lst.remove(22)
print(lst)
# pop(index) 按索引删除,不写index删除最后一个元素
lst.pop(0)
print(lst)
# del 列表名[index]
del lst[0]

# 清空 clear()
# lst.clear()
# print(lst)

# del 列表名，删除后不能使用此对象
# a = [1,2,3,4,5]
# del a
# print(a) # name 'a' is not defined

其他

# 统计
# len(列表) 统计元素个数
lst = [1,2,3,4,5]
print(len(lst))
# 列表名.count(元素)，统计列表中某个元素出现的次数
print(lst.count(1))
# max()求最大值
# min()求最小值
print(max(lst))

# 排序 sort() 默认升序 降序：reverse=True
lst.sort(reverse=True)
print(lst)
# sorted() 开辟新空间

元组tuple

特点：

  1. 不可变的序列，不能增删改，修改后地址会发生变化
  2. 参考定长数组
  3. 有索引
  4. 有序
  5. 元素类型不限

创建

# 创建
# 1.使用（）,小括号可以省略
t = (1,2,3,'helo',[1,2,3])
print(t,type(t))
t = 2,
print(t,type(t))
# 2.使用tuple()
t3 = tuple()
print(t3,type(t3))
t3 = tuple((11,22,33,'hello'))
print(t3,type(t3))
lst =[5,4,3,2,1]
t4 =tuple(lst)
print(t4,type(t4))
#3.元组没有生成式

获取元素

# 获取单个元素：索引,不存在则报错
t = (1,2,3,4,5)
print(t[0])
# 获取多个元素：切片  对象名[start:end:step]
print(t[1:4])
# 遍历
for i in t:
    print(i)
# in /not in
print(1 in t)
print(1 not in t)

# index()
print(t.index(5))

# len()
print(len(t))

# max() min()
print(max(t))

不能做的事情

# 元组：不能增删改查
# 元组中的元素地址是不能改的
# 元组中的元素如果是不可变对象，通过可改变对象的增删改查，是可以改变的
t = (1,2,[3,4])
lst =t[2]
lst[1]=3
print(lst,type(lst))

集合set

特点：

  1. 不重复，无序
  2. 参考数学上的集合：不重复，无序
  3. 底层实现：哈希表
  4. 集合储存的对象都是不可变的序列
  5. 没有索引
  6. 集合是没有value的字典

创建

# 1.使用{}
s ={1,2,3,1,1,1,64,'helo',(2,3)}
print(s,type(s))
# 集合存储的对象都是不可变对象
# s = {},不能创建空集合
# print(s,type(s))

# 2.set()
s2 = set({2,3,4,5})
print(s2,type(s2))
s2 = set([1,5,23,2,5])
print(s2,type(s2))
s2 =set((1,5,23,2,5))
print(s2,type(s2))
s2 = set('hello')
print(s2,type(s2))

# 3.使用生成器
s3 ={i*i for i in range(3)}
print(s3,type(s3))

获取元素

# 获取元素
# 集合没有索引，没有办法单个获取
# 不能使用切片
# 遍历
s = {23,1,2,34,56}
for i in s:
    print(i)

# in /not in
print(23 in s)

增删改

# 增删改
s = {10,20,30,40}
# 增加一个元素 .add()
s.add(68)
print(s)
# 增加多个元素
s.update([1,2,3])
s.update((11,22,33))
s.update({111,222,333})
print(s)

# 删除
# .remove(ele) 如果对象不存在会报错
s.remove(10)
print(s)
# .discard 如果对象不存在，无效果，不报错
s.discard(30)
print(s)
# .clear（）
s.clear()
print(s)

# 修改==先删再添
其它操作
# 其他操作
s = {1,2,3,4,5}
l =len(s)
print(l)

# max min
m = max(s)
print(m)

# 排序
print(s,type(s),id(s))
s =sorted(s)
print(s,type(s),id(s))
集合在数学方面的操作
a = {1,2,3}
b = {1,2,4}
# 交集
print(a.intersection(b))
# 并集
print(a.union(b))
# 差集
print(a.difference(b))
print(b.difference(a))
# 对称差集
print(a.symmetric_difference(b))

# 集合间关系
a = {1,2}
b = {1,2,4}
# 是否是子集
print(a.issubset(b))
# 是否是父集
print(b.issuperset(a))
# 是否没有交集
print(a.isdisjoint(b))

字典dict

字典是另一种可变容器模型，且可存储任意类型对象。

字典的每个键值 key=>value 对用冒号 : 分割，每个键值对之间用逗号 , 分割，整个字典包括在花括号 {} 中 ,格式如下所示：

d = {key1 : value1, key2 : value2 }

特点：

  1. 字典中的所有元素都是一个键值对，key不允许重复，value可以重复
  2. 无序
  3. key必须是不可变对象
  4. 字典也可以根据需要动态地伸缩
  5. 字典会浪费较大的内存，是一种使用空间换时间的数据结构

创建

# 创建
# 1.使用{}
d = {'name':'zhangsan','age':20}
print(d,type(d))
# 2.dict()
d2 =dict()
print(d2,type(d2))
d2 =dict({'name':'zhangsan','age':20})
print(d2,type(d2))
# 3.字典推导式
name = ['zhangsan','lisi']
age = [16,18]
# zip() 将两个列表打包，生成元祖
z = zip(name,age)
for item in z:
    print(item)
d3 ={name:age for name,age in zip(name,age)}
print(d3,type(d3))

获取元素

# 获取元素
# 根据key获取元素
d = {'name':'jack','age':23}
print(d['name'])
# 字典名.get(key)
print(d.get('name'))

# 遍历
dk =d.keys()
print(dk,type(dk))
dv = d.values()
print(dv,type(dv))

# 遍历键
print('-----------------')
for i in d:
    print(i,d[i])

# 遍历键值对
print('-----------遍历键值对')
for item in d.items():
	print(item[0],item[1])
for key,value in d.items():
	print(key,value)

总结

  • 列表：有序，可重复，可变长，有索引，任意类型数据 []
  • 元组：有序，可重复，不可变，有索引，任意类型数据 ()
  • 集合：无序，不重复，可变长，无索引，不可变数据， {}
  • 字典：无序，key不重复，value可重复，可变长，无索引，有键，键值对（key不可变数据）{}