数据容器：可以存储多个元素的数据类型
列表list、元组tuple、字符串str、集合set、字典dict

列表：可修改，元素可重复，元素间有序，可下标索引
元组：不可修改，元素可重复，元素间有序，可下标索引
字符串：不可修改，元素可重复，元素间有序，可下标索引
集合：可修改，元素不可重复，元素间无序（因此不支持下标索引访问）
字典：可修改，元素不可重复，不支持下标索引访问

存字符串选字符串，不可修改选元组，不可重复选集合，键值选字典，其他选列表

文章目录

1.列表 list
2.元组 tuple
3.切片
4.集合 set
5.字典 dict

1.列表 list

a=["hello",1,1.5]
print(a) # ['hello', 1, 1.5]
print(a[0]) # hello
print(a[-1]) # 1.5
print(a[0:2]) # ['hello', 1]
a[2]=6
print(a[2]) # 6
a.append("新增") # 通过append新增元素
print(a) # ['hello', 1, 6, '新增']
a.extend([1,2,3,4,5]) # 通过extend一次增加多个值
print(a) # ['hello', 1, 6, '新增', 1, 2, 3, 4, 5]
del a[1] # 通过del删除元素
print(a) # ['hello', 6, '新增', 1, 2, 3, 4, 5]
print(len(a)) # 8  通过len求元素个数(列表长度)
b=["ha",2]
c=a+b #列表拼接
print(c) # ['hello', 6, '新增', 1, 2, 3, 4, 5, 'ha', 2]
print(b*4) # ['ha', 2, 'ha', 2, 'ha', 2, 'ha', 2] 列表重复输出四次
print([2,"ao"]*3) # [2, 'ao', 2, 'ao', 2, 'ao'] 给定列表输出# if 判断
b=["ha",2]
if 2 in b:print("1")
else:print("2")
# 1# for循环
b=["ha",2]
for x in b:print(x)
"""
ha
2
"""# while
b=["ha",2]
i=0
while i<len(b): # 列表b的元素个数print(b[i])i+=1
"""
ha
2
"""#嵌套
print(a) # ['hello', 6, '新增', 1, 2, 3, 4, 5]
print(b) # ['ha', 2]
y=[a,b]
print(y) # [['hello', 6, '新增', 1, 2, 3, 4, 5], ['ha', 2]]
print(y[1][1]) # 2 第1组第1个(从0起)#列表比较
import operator
a=[1,2]
b=[2,3]
c=[2,3]
print(operator.eq(a,b)) # False
print(operator.eq(b,c)) # True# 最值(min同理)
a,b=["apple","bpple","cpple"],[1,2,3]
print(max(a)) # cpple  比较第一个字符的ASCLL码，若相等再同时比较第二个
print(max(b)) # 3
a=["apple",6]
#print(max(a)) # error 只能比较相同元素类型# 统计某个元素的出现次数 list.count(obj)
a=[2,2,2,2,2,5,6,7,8,9,4,"haha"]
print(a.count(2)) # 5# 索引index
a=[3,2,1,4,3,1,2,3]
print(a.index(1)) # 2  列表a中第一次出现1的位置
print(a.index(1,3,7)) # 5  从下标3到7，找到首次出现1的位置# 移除列表中的元素，并且返回值 a.pop()
a=[]
a.append("a")
a.extend([1,2,3])
print(a) # ['a', 1, 2, 3]
del a[3] # 删除下标3的元素
print(a) # ['a', 1, 2]
print(a.pop(1)) # 1  删除了下标为1的元素1，返回值为被删除元素
print(a) # ['a', 2]
print(a.pop()) # 2 不写参数默认删除最后一个# 移除列表某个值的第一个匹配项 remove()
a=["haha","aoao","hehe","aoao"]
a.remove("aoao")
print(a) # ['haha', 'hehe', 'aoao']# 列表元素取反
a=[1,2,3,4,5]
a.reverse()
print(a) # [5, 4, 3, 2, 1]# 排序
a=[2,3,1,5,6]
a.sort()
print(a) # [1, 2, 3, 5, 6]
a.sort(reverse=True) # False升序(默认)
print(a) # [6, 5, 3, 2, 1]# 清空列表 clear()
a=[1,2]
a.clear()
print(a) # []# 列表复制
a=[1,2]
b=a.copy()
print(b) # [1, 2]# 元素插入 insert在指定位置插入元素
a=[]
a.append(1) # 添加到尾部
print(a) # [1]
a.insert(0,"hello") # 下标位置、插入元素
print(a) # ['hello', 1]
a.extend(["da",2,3]) # 批量添加
print(a) # ['hello', 1, 'da', 2, 3]

2.元组 tuple

元组不能修改元素内容（增加/删除某个元素/更新），但可以修改元组中的列表

a=("haha",1,2)
b="haha",1,2,3
print(a) # ('haha', 1, 2)
print(b) # ('haha', 1, 2, 3)
print(a[1]) # 1
print(a[0:2]) # ('haha', 1)
print(a[-1]) # 2
print(a+b) # ('haha', 1, 2, 'haha', 1, 2, 3)
print(len(a)) # 3
#a[0]=1 # error 元组中的元素值不能修改
#del a[0[ # error 元组中的元素值不能删除del a #可以通过del删除元组
#print(a) # error 删除后无法使用(未定义)a=(10)
print(type(a)) # <class 'int'>
a=(10,)
print(type(a)) # <class 'tuple'># 列表转元组
a=["haha","hehe",1,2]
b=tuple(a)
print(b) # ('haha', 'hehe', 1, 2)# 定义空元组
a=()
b=tuple()
print(a) # ()
print(b) # ()# 元组嵌套
a=(1,2,3)
b=(4,5,6)
c=(a,b)
d=((1,2,3),(2,3,4))
print(c) # ((1, 2, 3), (4, 5, 6))
print(d) # ((1, 2, 3), (2, 3, 4))
print(c[1][2]) # 6 注意用中括号# index(value,start,stop) 返回第一次出现的下标
a=(1,2,3,2)
print(a.index(2,0,2)) # 1
print(a.count(2)) # 2 count(value) 返回value出现的次数# while
a=1,2,3,4,5
i=0
while i<len(a):print(a[i],end=" ") # 1 2 3 4 5i+=1
print()# for
a=1,2,3,4,5
for x in a:print(x,end=" ")  # 1 2 3 4 5
print()# 修改元组中的列表
a=(1,2,3,[4,5,6])
a[3][1]=7
print(a) # (1, 2, 3, [4, 7, 6])

3.切片

元组、列表、字符串都可以进行切片
切片不会对原字符串修改，会返回一个新的字符串
a[start: end :step]
步长可省略，默认为1
省略start表示从头(含)/尾(含)开始
省略end表示到尾(含)/头(含)结束

列表

b=["ha",1,2,3,4,5]
b1=b[1:5:2] #下标从1到4，步长为2
print(b) # ['ha', 1, 2, 3, 4, 5]
print(b1) # [1, 3]

元组

c=("dd",6,7,8,9,10)
c1=c[:] # 从起始到结束(含)，步长为1
print(c1) # ('dd', 6, 7, 8, 9, 10)

字符串

a="hello world"
a1=a[::2] # 从头到尾，步长为2
print(a1) # hlowrd

a="hello world"
a1=a[::-1] # 步长为-1,表示从尾到头切片
print(a1) # dlrow olleh
a1=a[7:3:-1] #从7号到3号(不含)切片，步长为-1
print(a1) # ow o
a1=a[7:3:-2] # 步长为-2
print(a1) # o

4.集合 set

确定性、互异性、无序性
（1）定义

a={"as","sad","da"}
b=set(("as","sad","da")) # 集合的参数列表是元组
c=set(["as","sad","da"]) # 集合的参数列表是列表
print(a)
print(b)
print(c)
# 输出均为:{'da', 'sad', 'as'}

a=set("abcdefg")
print(a) # {'c', 'b', 'e', 'g', 'f', 'a', 'd'}a=set() # 空集合
print(a) # set()

（2）运算

a=set("abcde")
b=set("defgh")
print(a-b) # {'a', 'c', 'b'}
print(a.difference(b)) # {'b', 'c', 'a'}
#差集,与a-b相同,即在a中但不在b中的元素
print(a|b) # {'d', 'h', 'c', 'g', 'f', 'e', 'a', 'b'}
print(a&b) # {'d', 'e'}print(a^b) # {'g', 'f', 'a', 'h', 'c', 'b'}
# 不同时在a、b中,即 (a|b)-(a&b)

（3）添加
添加的参数可以是列表、元组、字典等

a=set()a.add(1) # add每次只能加一个
print(a) # {1}a.update({2})
print(a) # {1, 2}a.update({3,"ao"})
print(a) # {1, 2, 3, 'ao'}a.update([5,"haha"])
print(a) # {1, 2, 3, 5, 'haha', 'ao'}

（4）移除

a={1,2,3,4,5,6}a.remove(3) # 移除元素3，若3不存在会报错
print(a) # {1, 2, 4, 5, 6}a.discard(4) # 移除元素4，若4不存在不会报错
print(a) # {1, 2, 5, 6}a.pop() # 随机删除一个元素，集合不支持下标索引，所以不能指定
# pop有返回值，可用变量接收
print(a) # {2, 5, 6}

（5）计数&清空

a=set(("apple","bpple","cpple","dpple"))
print(len(a)) # 4a.clear() # 清空集合
print(a) # set()

（6）判断元素是否在集合中存在

a=set(("apple","bpple"))
print("bpple" in a) # True

（7）消除交集/保留差集

a={1,2,3,4,5}
b={3,4,5,6,7}
print(a.difference(b)) # {1, 2}
a.difference_update(b) # 在a中消除两个集合相同的元素
# a-(a&b)=a-b 即a的值改为差集的值,即a独有的值
print(a) # {1, 2}
print(b) # 不变 {3, 4, 5, 6, 7}

（8）集合合并
集合a、b的值不变

a={1,2,3}
b={1,5,6}
print(a.union(b)) # {1, 2, 3, 5, 6}  注意集合的互异性

（9）for循环

a={1,2,3,4,5}
for x in a:print(x,end="") # 12345

5.字典 dict

name叫做键(key)，键必须唯一，且不能修改
black叫做值(value)，值可以不唯一，可以修改
键可以用数字、字符串、元组，但不能用列表
值可以取任意数据类型
如果有多个相同的key，只会保留最后一个

a={"name":"black","age":18,"likes":"basketball"}
print(a) # {'name': 'black', 'age': 18, 'likes': 'basketball'}a={} # 空字典
b=dict() # 空字典
print(a) # {}
print(b) # {}

（1）访问值

a={"name":"black","age":18,"likes":"basketball"}
print(a["name"]) # black
print(a["age"]) # 18

（2）修改与插入

a={"name":"black","age":18,"likes":"basketball"}
a["name"]="red" # 已有更新
print(a) # {'name': 'red', 'age': 18, 'likes': 'basketball'}a={"age":18,"name":"jack"}
a["likes"]="basketball" # 没有新增
print(a) # {'age': 18, 'name': 'jack', 'likes': 'basketball'}

（3）删除
clear与del

a={"name":"black","age":18,"likes":"basketball"}del a["name"]
print(a) # {'age': 18, 'likes': 'basketball'}a.clear() # 删除字典中所有元素，但不删除字典
print(a) # {}del a # 删除字典
print(a) # error: name 'a' is not defined

pop

a={"age":18,"name":"jack"}
b=a.pop("name") #返回值为被删除元素的value
print(a) # {'age': 18}
print(b) # jacka.pop("sasa") # error 不存在此键，引发异常
print(a.pop("sasa","提示信息")) # 输出:提示信息
# 通过提示信息处理异常，使程序正常运行

popitem
采用LIFO的方式，删除最后一个插入的键值/末尾的键值（元组返回）

a={"age":18,"name":"jack"}
b=a.popitem() # 返回值为元组形式，存入b
print(a) # {'age': 18}
print(b) # ('name', 'jack')
print(type(b)) # <class 'tuple'>

（4）len

a={"name":"black","age":18,"likes":"basketball"}
print(len(a)) # 3

（5）拷贝
详见12-python内存地址

a={"name":"black","age":18,"likes":"basketball"}
b=a.copy()
print(b) # {'name': 'black', 'age': 18, 'likes': 'basketball'}
c=a
print(c) # {'name': 'black', 'age': 18, 'likes': 'basketball'}a["name"]="red"
print(b) # {'name': 'black', 'age': 18, 'likes': 'basketball'}
print(c) # {'name': 'red', 'age': 18, 'likes': 'basketball'}

（6）创建新字典fromkeys()

seq=("name","age","likes")
a=dict.fromkeys(seq) #从seq中取键生成字典给a,值为默认None
print(a) # {'name': None, 'age': None, 'likes': None}
a=dict.fromkeys(seq,10) # 值均为10
print(a) # {'name': 10, 'age': 10, 'likes': 10}

（7）get()与setdefault()方法
get(key) 当键不存在时返回默认值None
get(key,value) 当键不存在时返回value
dict[key] 当键不存在时触发异常

a={"name":"black","age":18,"likes":"basketball"}print(a.get("name")) # black
print(a["name"]) # blackprint(a.get("aaaa")) # None
print(a.get("aaaa",6)) # 如果aaaa不在字典的键中，返回6
print(a["aaaa"]) # error 找不到

setdefault()
当键不存在时，会返回None(默认)或设置的值，并且将所查询的key值加入字典中，新加入的key对应的键值为None(默认)或设置值

a={"name":"black","age":18}print(a.setdefault("aaaaa")) # None
print(a) # {'name': 'black', 'age': 18, 'aaaaa': None}print(a.setdefault("bbbbb",6)) # 6
print(a) # {'name': 'black', 'age': 18, 'aaaaa': None, 'bbbbb': 6}

嵌套

a={"name":{"age":18}}
print(a) # {'name': {'age': 18}}b=a.get("name")
print(b) # {'age': 18}b=a.get("name").get("age")
print(b) # 18

a={"xiaoming":{"语文":100,"数学":99},"xiaohong":{"语文":99,"数学":100}
}
print(a)
# {'xiaoming': {'语文': 100, '数学': 99}, 'xiaohong': {'语文': 99, '数学': 100}}
print(a["xiaoming"]["语文"]) # 100

（8）in操作符

a={"name":"black","age":18,"likes":"basketball"}
if "name" in a:print(1)
if "aaaa" not in a:print(2)

（9）items以列表返回一个视图对象
将字典中的所有项，以列表的方式返回，字典是无序的，所以items返回的结果也是无序的

a={"name":"black","age":18}
print(a.items()) # dict_items([('name', 'black'), ('age', 18)])for i in a: # i为视图中所有key的值print(i,end=" ") # name agefor i,j in a.items(): # items中的key给i，value给jprint(j)
"""
black
18
"""
# 求平均分
a = {"apple": 100, "bpple": 99, "cpple": 98, "dpple": 97}
sum = 0
for key, value in a.items():sum = sum + value # 求和print(key, ':', value)
print('平均分为:', sum / len(a))
"""
apple : 100
bpple : 99
cpple : 98
dpple : 97
平均分为: 98.5
"""

视图对象不是列表，不支持索引，可以使用list()转换为列表
不能对视图对象进行任何的修改，字典的视图是只读的

a={"name":"black","age":18}
b=list(a.items())
print(b[0]) # ('name', 'black')

（10）keys与values

a={"name":"black","age":18}
jian=a.keys()
zhi=a.values()
print(jian) # dict_keys(['name', 'age'])
print(zhi) # dict_values(['black', 18])
for x in jian:print(x) # 当前键print(a[x]) # 当前键对应的值
"""
name
black
age
18
"""

（11）update更新

a={"age":18}
b={"name":"jack"}
a.update(b)
print(a) # {'age': 18, 'name': 'jack'}

（12）max
max比较的是键首字母的ASCII码大小，不关心value

a={"apple":5,"bpple":3}
print(max(a)) # bpple

字符串相关见 7.字符串

4-python数据容器相关推荐

python入门(六)——python数据容器
系列文章目录 python入门(一)--你好python python入门(二)--python基础语法 python入门(三)--python判断语句 python入门(四)--python循环语句 ...
python数据容器专题
Python容器专题 [导读] 容器通常属于序列(如列表或元组)或映射(如字典),但也存在其他形式的容器.依据Python官方的说法,Python语言中标准内建容器包括 dict , list , s ...
Python数据容器：list + set + tuple + dict + str 简记黑马课程
# -*- coding:utf8 -*- """ # editor: hjjdreamer # create-time: 2022/11/16-23:08 # Pyth ...
【Python基础】Python数据容器（集合）
文章目录数据容器:set(集合) 集合的定义集合的常用操作-修改 (1)添加新元素 (2)移除元素 (3)从集合中随机取出元素 (4)清空集合 (5)取出两个集合的差集 (6)消除两个集合的差 ...
【Python基础】Python数据容器（字典）
文章目录数据容器:dict(字典.映射) 字典的定义字典数据的获取字典的嵌套字典的注意事项字典的常用操作 (1)新增元素 (2)更新元素 (3)删除元素 (4)清空字典 (5)获取全部key ...
【Python基础】Python数据容器（元组）
文章目录数据容器:tuple(元组) 元组的定义格式元组的相关操作元组的相关操作-注意事项元组的特点数据容器:tuple(元组) 元组的定义格式元组定义:定义元组使用小括号,且使用逗号隔开 ...
【Python基础】Python数据容器（字符串）
文章目录数据容器:str(字符串) 字符串的常用操作 (1)查找特定字符串的下标索引值 (2)字符串的替换 (3)字符串的分割 (4)字符串的规整操作(去前后空格) (5)字符串的规整操作(去前后指 ...
python数据容器之集合、字典
set集合基本语法: # 定义集合字面量 (元素,元素,--元素) # 定义集合变量变量名称 = (元素,元素,--元素) # 定义空集合变量名称 = set() 列表使用 [] 元组使用 () ...
3. Python 数据容器（列表、元组、字符串、集合、字典）
1. 数据容器入门数据容器:一种可以容纳多份数据的数据类型,容纳的每份数据称为一个元素. 每个元素,可以是任意类型数据,如:字符串.数字.布尔等. 数据容器根据特点的不同,如: 是否支持重复元素是 ...
Python数据容器(五)
python学习之旅(五) 学习汇总入口[Python]学习汇总(3万字+思维导图) 写作不易,如果您觉得写的不错,欢迎给博主来一波点赞.收藏~让博主更有动力吧! 一.数据容器一种可以容纳多份数据的 ...

4-python数据容器