本文详细介绍了Python中的五种主要数据结构：字符串、列表、元组、字典和集合。内容涵盖它们的定义、特点、操作方法以及彼此之间的对比。例如，字符串的索引、切片、查找、拆分和编码，列表的增删改查及排序，元组的创建与访问，字典的添加、删除和修改操作，以及集合的添加、删除和关系运算。
目录
存储类型
名称 定义 格式
字符串
字符串是一个有序的，不可修改的，元素以引号包围的序列。
python字符串的定义：双引号或者单引号中的数据，就是字符串；字符串和字符串之间可以想加
列表
列表是一个有序的，可修改的，元素以逗号分割，以中括号包围的序列。
列表的索引和字符串的索引类似，但不完全相同，因为列表可以修改，所以我们可以通过列表的索引来修改列表。可变数据类型
变量名= [元素1,元素2,元素3,...]
元组
元组是有序的，不能修改。
- .通过()来定义：变量名=(1,2,3,4,) 。以逗号分割的，以小括号包围的序列。
- .通过tuple函数定义: lst=[1,2,3,4] 变量名=tuple(lst) 不可变数据类型
变量名=(1,2,3,4,)
字典
字典是一个无序的，可以修改的，元素呈键值对的形式，以逗号分割的，以大括号包围的序列；
字典是python基础数据类型当中唯一一个映射关系的数据类型；
由于字典无序，所以我们定义字典和字典生成之后的元素的顺序是不同的；
可变数据类型
字典格式： 变量名={key;value,key:value...}
集合
集合与之前列表、元组类似，可以存储多个数据，但是这些数据是不重复的(具有自动去重功能)。
集合对象还支持交集(intersection),差集(difference)、并集和对称差集(sysmmetric_difference)
- 变量名={元素1，元素2，元素3，...}
- . 变量名=set(序列) 例如 变量名=set(元组，自动，字符串
一，字符串
1.字符串的索引(index)
2.字符串切片：
切片的语法：[起始:结束:步长] 字符串[start:end:step]
默认取法：字符串[start:end,step] 这三个参数都有默认值、start；默认值为0；end 默认值未字符串结尾元素；step 默认值为1
a = 'abcdefgh'
print(a[0:5:1]) #abcde
print(a[1:5:1]) #bcde
print(a[1:5:]) #bcde
print(a[1:5:2]) #bd
print(a[:5:]) #abcde
print(a[::]) #abcdefgh
print(a[::-1]) #hgfedcba #步长从右向左
print(a[-8:-2:1]) #abcdef
print(a[-2:-8:-1]) #gfedcb 包头不包尾
ret = a[0:5:1]
print(ret) #abcde
ret=a[3] # d 是索引
print(ret)
a = 'abcdefgh'
print(type(a))
length=len(a) #<class 'str'>
print(type(length)) # <class 'int'>
print(length) # 83.字符串的查找
|
字符串的查找 | count | 计数功能，返回自定字符在字符串当中的个数 |
|
| find | 查找，返回从左第一个指定字符的索引，找不到返回-1 |
|
| rfind | 查找，返回从右第一个指定字符的索引，找不到返回-1 |
|
| index | 查找，返回从左第一个指定字符的索引，找不到报错 |
|
| rindex | 查找，返回从右第一个指定字符的索引，找不到报错 |
s='hello,world python'
ret =s.count('orl')
print(ret) # 1
retx =s.count('l')
print(retx) # 3
ret1=s.find('l')
print(ret1) #2
ret2 = s.find('ld')
print(ret2) #9 包含第查找的数
ret3= s.find('hhh')
print(ret3) # -1 找不到就返回-1 从左往右查找
ret4 = s.rfind('l')
print(ret4) # 9 从右往左查找
ret5= s.rfind('hhh')
print(ret5) # -1 找不到的返回 -1
s='hello,world python'
ret = s.index('l')
print(ret) # 2 从左到右找
ret1=s.rindex('l')
print(ret1) # 9 从右向左 找
4.字符串的拆分
| 字符串的分割 | partition | 把mystr以str分割成三部分,str前，str自身和str后 |
| 字符串的分割 | splitlines | 按照行分隔，返回一个包含各行作为元素的列表,按照换行符分割 |
| 字符串的分割 | split | 按照指定的内容进行分割 |
s='hello world python'
ret = s.partition('world') #分成（前，本身，后）三部分
print(ret) #v('hello ', 'world', ' python')
s='hello\tworld\tpython' # \t 分割 \n 换行
ret = s.splitlines()
print(ret) #['hello world python']
s='hello\tworld\tpython'
ret = s.splitlines()
print(ret) # ['hello\tworld\tpython']
s='hello\nworld\npython'
ret = s.splitlines() # keepends=False 默认
print(ret) #['hello', 'world', 'python']
ret = s.splitlines(keepends=True) # 显示换行符
print(ret) # ['hello\n', 'world\n', 'python']
s='hello world python'
ret=s.split('r') # 去除分离字符，分成两部分,生成列表
print(ret) # ['hello wo', 'ld python']
ret1=s.split('l')
print(ret1) #['he', '', 'o wor', 'd python']
5.字符串的替换
| 字符串的替换 | replace | 从左到右替换指定的元素，可以指定替换的个数，默认全部替换 |
|
| translate | 按照对应关系来替换内容 from string import maketrans |
s='hello world python'
ret = s.replace('o','0') # 字符串用字符串替换
print(ret) # hell0 w0rld pyth0n
ret1 = s.replace('o','0',2) # 2,为指定从左往右总共替换两个
print(ret1) # hell0 w0rld python
s='hello world python'
intab = 'ol' #o--->a l---->e
outab = 'ae'
ret2=str.maketrans(intab,outab)
s1 = s.translate(ret2)
print(s1)
6.字符串的修饰
| 字符串的修饰 | center | 让字符串在指定的长度居中，如果不能居中左短右长，可以指定填充内容，默认以空格填充 |
|
| ljust | 让字符串在指定的长度左齐，可以指定填充内容，默认以空格填充 |
|
| rjust | 让字符串在指定的长度右齐，可以指定填充内容，默认以空格填充 |
|
| zfill | 将字符串填充到指定的长度，不足地方用0从左开始补充 |
|
| format | 按照顺序，将后面的参数传递给前面的大括号 |
|
| strip | 默认去除两边的空格，去除内容可以指定 |
|
| rstrip | 默认去除右边的空格，去除内容可以指定 |
|
| lstrip | 默认去除左边的空格，去除内容可以指定 |
s = 'hello'
print(s)
ret = s.center(10)
print(ret) # hello
ret1 = s.center(12,'*')
print(ret1) #***hello****
s = 'hello'
print(s)
ret = s.ljust(13)
print(ret) #hello #
ret2 = s.ljust(13,'*')
print(ret2) #hello********#
s = 'hello'
ret= s.zfill(13)
print(ret) #00000000hello#
s=' hello python '
ret = s.strip() #默认去除两边的空格
print(ret) #hello python#
s='***hello world****'
ret = s.strip('*') #去除*
print(ret) #hello world#
s=' hello python '
print(s)
ret = s.rstrip()
print(ret) # hello python# 去除右边的空格键
s=' hello python '
ret=s.lstrip()
print(ret) #hello python # 去除左边的空格键
s='**hello python '
ret = s.lstrip('*')
print(ret) #hello python # 去除左边的*
name = 'zs'
age=10
msg = '大家好！我叫{}，今年年龄{}'.format(name,age)
print(msg) #大家好！我叫zs，今年年龄10
msg = '大家好！我叫{0}，今年年龄{0},住在那{1}'.format(name,age)
print(msg) #大家好！我叫zs，今年年龄zs,住在那10
msg = '大家好！我叫{0}，我叫{1}，我叫{0},年龄{1}'.format('张三',18)
print(msg) #大家好！我叫张三，我叫18，我叫张三,年龄18
print('大家好，我叫{name},住在{where},年龄{age}'.format(name='zs',where='bj',age=19))
#大家好，我叫zs,住在bj,年龄19
print('大家好，我叫{name},住在{name},年龄{age}'.format(name='zs',age=19))
#大家好，我叫zs,住在zs,年龄19
#*** < 表示 向左对齐， ^ 表示居中对齐， >表示向右对齐 :[填充字符][对齐方式 <^>][宽度]
print('我叫{:*^5},年龄{:&<7}'.format('张三风',50))
#我叫*张三风*,年龄50&&&&&
msg = '长方形的长是{:.2f},宽{:.3f},面积{:.2f}'
chang = 5/3
kuan = 9/4
area = chang*kuan
print(msg.format(chang,kuan,area)) # 长方形的长是1.67,宽2.250,面积3.75
7.字符串的变形
|
字符串的变形 | upper | 将字符串当中所有的字母转换为大写 |
| lower | 将字符串当中所有的字母转换为小写 | |
| swapcase | 将字符串当中所有的字母大小写互换 | |
| title | 将字串符当中的单词首字母大写，单词以非字母划分 | |
| capitalize | 只有字符串的首字母大写 | |
| expandtabs | 把字符串中的 tab 符号('\t')转为空格，tab 符号('\t')默认的空格数是 8 |
# s='hello python'
# ret=s.upper()
# print(ret) #将所有的小写换成大写 #HELLO PYTHON
# s='HELLO PYTHON'
# ret = s.lower()
# print(ret) #hello python 将大写改成小写
# s='Hello Python'
# ret = s.swapcase()
# print(ret) #hELLO pYTHON 将大小写互换
# s='hello python'
# ret=s.title()
# print(ret) #Hello Python 将每个单词首个字母大写
# s='hello python'
# ret=s.capitalize()
# print(ret) #Hello python 将字符串的首个字母大写
# s='hello\tpython'
# ret = s.expandtabs()
# print(ret) #hello python 将\t转换为8个字符，
# s='hello\tpython'
# ret =s.expandtabs(tabsize=10)
# print(ret) #hello python# 空格数=tabsize-前面的字符数
8.字符串的判断
| 字符串的判断 | isalnum | 判断字符串是否完全由字母或数字组成 |
|
| isalpha | 判断字符串是否完全由字母组成 |
|
| isdigit | 判断字符串是否完全由数字组成 |
|
| isupper | 判断字符串当中的字母是否完全是大写 |
|
| islower | 判断字符串当中的字母是否完全是小写 |
|
| istitle | 判断字符串是否满足title格式 |
|
| isspace | 判断字符串是否完全由空格组成 |
|
| startswith | 判断字符串的开头字符，也可以截取判断 |
|
| endswith | 判断字符串的结尾字符，也可以截取判断 |
|
| split | 判断字符串的分隔符切片 |
s='adbf123om'
s1 = s.isalnum()
print(s1) #True 判断字符串是否有数字或字母组成
s2 ='num_123num'
s3 =s2.isalnum()
print(s3) #False
s='bunm123nij'
s1=s.alpha()
print(s1) #False #判断字符串是否有字母组成
s='EVCmkmc'
s1=s.isalpha()
print(s1) #True
s='123n4cid'
s1=s.isdigit()
print(s1) #False 判断字符串是否有数字组成
s='12455'
s1=s.isdigit()
print(s1) #True
s='HELLO PYTHON'
s1=s.isupper()
print(s1) #True 判断字符是否是大写组成
s='hEllo pytHon'
s1 =s.isupper()
print(s1) #False
# s='hEllo pytHon'
# s1 =s.islower()
# print(s1) #False 判断字符是完全有小写字母组成
# s='asdvgbf'
# s1 = s.islower()
# print(s1) #True
s='Hello Python'
s1=s.istitle()
print(s1) #True 判断每个单词的首字母是否大写
s='Hello python'
s1= s.istitle()
print(s1) #False
# s= ' '
# s1=s.isspace()
# print(s1) #True 判断字符串是否有空格组成
# s=' s '
# s1 =s.isspace()
# print(s1) #False
# s='hello world'
# s1=s.startswith('lo')
# print(s1) #False 判断开头是否有指定的字符开头
# s='hello world'
# s1=s.startswith('h')
# print(s1) #True
# s = 'hello world'
# s1=s.endswith('ld')
# print(s1) #True 判断末尾是否是指定字符
s = 'hello world'
s1=s.endswith('o')
print(s1) #False
s = 'hello world'
s1=s.endswith('w',3,6)
print(s1) #False
ret=s.endswith('w',3,7)
print(ret) #True 包头不包尾
s='hello world'
s1=s.split('o') #分离并消除 生成列表
print(s1) #['hell', ' w', 'rld']
9.字符串的编码
encode是编码,将字符串转换成字节码。str-->byte
decode是解码 ,将字节码转换成字符串。 byte-->str
s='我'
# ret = s.encode() #默认编码表
# print(ret) # b'\xe6\x88\x91'
# ret1= ret.decode()
# print(ret1) # 我
# s='我'
# ret2=s.encode(encoding="gbk")
# print(ret2) #b'\xce\xd2'
# ret3 = ret2.decode(encoding='gbk') #指定什么编码表就用什么编码解，否则报错
# print(ret3) #我10. len() ord() chr()
# ret=len('中国')
# print(ret) #2
# print(ord('A')) #65
# print(chr(65)) #A二，列表
1.通过索引获取列表中的元素:
# name= ['zs','历史',1]
# print(name) #['zs', '历史', 1]
# print(type(name)) #<class 'list'>
# ret = name[1] #1为指定位置
# print(ret) #历史
2.列表的循环遍历
name= ['zs','历史',1]
for i in name:
print(i)
#输出：
zs
历史
1
|
列表的添加 | append | 追加，在列表的尾部加入指定的元素 |
|
| extend | 将指定序列的元素依次追加到列表的尾部(合并),不会去重复内容 |
|
| insert | 将指定的元素插入到对应的索引位上，注意负索引倒序插入，超过索引就会在末尾插入 |
|
列表的删除 | pop | 弹出，返回并删除指定索引位上的数据，默认删除索引为-1的数据(从右向左删除) |
|
| remove | 从左往右删除一个指定的元素 |
|
| del | 删除整个列表或列表的数据，del是python内置功能，不是列表独有的 |
| 列表的查找 注:列表没有find方法 | count | 计数，返回要计数的元素在列表当中的个数 |
|
| index | 查找，从左往右返回查找到的第一个指定元素的索引，如果没有找到，报错 |
| 列表的排序 | reverse | 顺序倒序 |
|
| sort | 按照ascii码表顺序进行排序 |
3.列表的添加
append、insert、extend方法、’+’ 加法 join()
lst= ['zs','历史',1]
lst.append('白骨精')
print(lst)
lst.insert(1,'袭人') #指定位置添加
print(lst) #['zs', '袭人', '历史', 1]
lst.extend('凯伦')
print(lst) #['zs', '历史', 1, '凯', '伦']
lst1=['赵云','马超','秦琼']
lst.extend(lst1)
print(lst) #['zs', '历史', 1, '凯', '伦', '赵云', '马超', '秦琼']
lst2= lst +lst1
print(lst2) #['zs', '历史', 1, '凯', '伦', '赵云', '马超', '秦琼']
s='hello'
s1='-'.join(s)
print(s1) # h-e-l-l-o
4.列表的删除
pop、remove、 clear、del 函数
# lst=['聂赫留朵夫','卢俊义','张顺','吕布','悟空','平儿']
# lst.pop(0) #指定位置删除索引，若没有就报错
# print(lst) # ['卢俊义', '张顺', '吕布', '悟空', '平儿']
# lst=['聂赫留朵夫','卢俊义','张顺','吕布','悟空','平儿']
# lst.remove('张顺') #根据内容删除
# print(lst) #['聂赫留朵夫', '卢俊义', '吕布', '悟空', '平儿']
lst=['聂赫留朵夫','卢俊义','张顺','吕布','悟空','平儿']
lst.clear() # 删除里列表面内容
print(lst) #[]
lst=['聂赫留朵夫','卢俊义','张顺','吕布','悟空','平儿']
del lst #清空内存
print(lst) #报错5.列表的修改和查找
修改使用索引 lists[0]=’xx’
lst= ['许诸','荀彧','徐庶','鲁肃']
lst[0]='吕布' #指定替换
print(lst) #['吕布', '荀彧', '徐庶', '鲁肃']查找操作：
1.使用索引，2.index()方法，3.count()统计，4.切片
name_list=['薛宝钗','春','夏','秋','冬']
name=name_list[0] # 通过索引查找
print(name) #薛宝钗
list=['笔','墨','纸','砚']
num= list.count('纸') #查找内容个数
print(num) #1
index=list.index('纸') #查找内容位置
print(index) #2
ret= list.index('墨',1,3) #(查找内容，开始位置，结束位置）
print(ret) #1
length=len(list) #查元素个数
print(length) #4
lst=['a','d','w',3,'h','u']
ret = lst[1:4:1] #[开启位置，终止位置，步长]
print(ret) #['d', 'w', 3]6. 列表的排序
sort、reverse
lst=['kaiwen','maliya','rula','duone']
lst.sort() #升序排列 默认reverse = False
print(lst) #['duone', 'kaiwen', 'maliya', 'rula']
lst.sort(reverse=True) #降序排列
print(lst) #['rula', 'maliya', 'kaiwen', 'duone']
lst.reverse() #翻转
print(lst) #['duone', 'rula', 'maliya', 'kaiwen']7.列表的深浅拷贝
浅拷贝 cope ：修改一层浅拷贝并不能修改内容，修改第二层，浅拷贝也被修改
l1=[1,2,['霍金','季羡林','anney']]
ret = l1[2][2] #获取anney
print(ret) #anney
l2=l1.copy()
print(l1,id(l1)) # [1, 2, ['霍金', '季羡林', 'anney']] 18152200
print(l2,id(l2)) # [1, 2, ['霍金', '季羡林', 'anney']] 18171912
l1=[1,2,['霍金','季羡林','anney']]
l2=l1.copy()
l2[1]=222 # 修改第一层内容
print(l1,id(l1)) #[1, 2, ['霍金', '季羡林', 'anney']] 12077064
print(l2,(id(l2))) #[1, 222, ['霍金', '季羡林', 'anney']] 12057352
l1=[1,2,['霍金','季羡林','anney']]
l2=l1.copy()
l2[2][0]='唐三' #修改第二层
print(l1,id(l1)) #[1, 2, ['唐三', '季羡林', 'anney']] 10877704
print(l2,id(l2)) #[1, 2, ['唐三', '季羡林', 'anney']] 10897416
深拷贝 导入 copy 模块。第一层，第二层都改了
Import copy
copy.deepcopy()
import copy
l1=[1,2,['霍金','季羡林','anney']]
l2 = copy.deepcopy(l1)
print(l1,id(l1)) #[1, 2, ['霍金', '季羡林', 'anney']] 18986184
print(l2,id(l2)) #[1, 2, ['霍金', '季羡林', 'anney']] 18986696
import copy
l1=[1,2,['霍金','季羡林','anney']]
l2 = copy.deepcopy(l1)
l2[0]='11111'
print(l1,id(l1)) #[1, 2, ['霍金', '季羡林', 'anney']] 18920648
print(l2,id(l2)) #['11111', 2, ['霍金', '季羡林', 'anney']] 18921160
import copy
l1=[1,2,['霍金','季羡林','anney']]
l2 = copy.deepcopy(l1)
l2[2][0]='唐三'
print(l1,id(l1)) #[1, 2, ['霍金', '季羡林', 'anney']] 18855112
print(l2,id(l2)) #[1, 2, ['唐三', '季羡林', 'anney']] 18855624
三，元组
1.创建元组和查看类型
tup = (1,2,3,4,5,6)
print(tup) #(1, 2, 3, 4, 5, 6)
print(type(tup)) #<class 'tuple'>
lst=[1,2,3,4,'s','f',5]
tup = tuple(lst) #列表转换成元组
print(tup) #(1, 2, 3, 4, 's', 'f', 5)2，访问元组
#单元组访问
tup=(1,2,3,4,'s','f',5,'hello')
print(tup[0]) #1
print(tup[-2]) #5
print(tup[0:4]) #(1, 2, 3, 4)
print(tup[0:6:2]) #(1, 3, 's') 从左向右，隔一个取一个
print(tup[:4]) #(1, 2, 3, 4)
print(tup[0:]) #(1, 2, 3, 4, 's', 'f', 5, 'hello')
print(tup[::]) #(1, 2, 3, 4, 's', 'f', 5, 'hello')
print(tup[-1:-6:-2]) #('hello', 'f', 4) 从右向左隔一个取一个
#多维元组访问
s=(('拿破仑',1),('迈顿',2),('白起',3))
print(s[0]) #('拿破仑', 1)
print(s[1][0]) #迈顿
#多个变量来接受元组
tup=('拿破仑','迈顿','白起')
name1,name2,name3=tup
print(name1) #拿破仑
print(name2) #迈顿
print(name3) #白起3.修改元组
tup = ('zs',1,'方鸿渐',['白骨精','貂蝉','西施'])
# tup[0]='范蠡'
# print(tup) #报错
tup[3].append('范蠡')
print(tup) #('zs', 1, '方鸿渐', ['白骨精', '貂蝉', '西施', '范蠡'])
tup[3].insert(1,'孙悟空')
print(tup) #('zs', 1, '方鸿渐', ['白骨精', '孙悟空', '貂蝉', '西施'])4元组的遍历
s=(('拿破仑',1),('迈顿',2),('白起',3))
for s1 in s:
print(s1)
for s2 in s1:
print(s2)
#输出：
('拿破仑', 1)
拿破仑
1
('迈顿', 2)
迈顿
2
('白起', 3)
白起
3
for name,num in s:
print(name)
print(num)
输出：
拿破仑
1
迈顿
2
白起
3
for name,num in s:
print(name,num)
输出
拿破仑 1
迈顿 2
白起 3
5.元组一个逗号的魅力
| 元组的查找 | index | 从左往右返回第一个遇到的指定元素的索引，如果没有，报错 |
|
| count | 返回元组当中指定元素的个数 |
# tup=('1')
# print(type(tup)) #<class 'str'>
tup = (1,)
print(type(tup)) #<class 'tuple'>
tup=(1)
print(type(tup)) #<class 'int'>
tup=('a','s','f','q','z','a','g','q')
print(tup.index('q')) #3
#print(tup.index('a',1,6)) #5 (查找内容，从1到6范围）
ret=tup.index('a',1,len(tup))
print(ret) #5
print(tup.count('a')) #2
四，字典
dic={'name':'孙悟空','age':1000,'height':60}
print(dic) #{'age': 1000, 'height': 60, 'name': '孙悟空'}
print(type(dic)) #<class 'dict'>1.字典的增加操作
通过key : info[key]= value
Setdefault(key,default_value)
dic={'name':'孙悟空','age':1000,'height':165}
dic.setdefault('weight',50) #添加 ，用逗号隔开
print(dic) #{'height': 165, 'age': 1000, 'name': '孙悟空', 'weight': 50}
dic.setdefault('where','花果山')
print(dic) #{'height': 165, 'age': 1000, 'name': '孙悟空', 'where': '花果山'}2.删除操作
|
字典的删除 | pop | 弹出，返回并删除指定键对应的值 |
|
| popitem | 随机弹出一个键值元组，这里随机的原因是因为字典无序 |
|
| clear | 清空字典 |
dic={'height': 165, 'age': 1000, 'name': '孙悟空', 'where': '花果山'}
dic.pop('age') #非、删除指定的关键字的键值对
print(dic) #{'where': '花果山', 'name': '孙悟空', 'height': 165}
dic.popitem() #{'height': 165, 'where': '花果山', 'name': '孙悟空'}
print(dic) #{'height': 165, 'age': 1000, 'where': '花果山'}随机删除一个
dic.clear()
print(dic) #{}对字典进行清空
del dic #del 与 字典之间是空格隔开
print(dic) #报错，删除内存3.修改操作
通过key来修改内容 info[key]=value
update()方法
dic={'name':'孙悟空','age':1000,'height':60}
dic['age']=800 #更改
print(dic) #{'name': '孙悟空', 'age': 800, 'height': 60}
dic={'height': 165, 'age': 1000, 'name': '孙悟空', 'where': '花果山'}
# dic1={'name':'八戒','hobby':'美女'}
# dic.update(dic1)
# print(dic) #{'age': 1000, 'hobby': '美女', 'height': 165, 'where': '花果山',
'name': '八戒'}
dic1={'ability':'打妖怪','teacher':'唐三藏'}
dic.update(dic1) #遇到重复关键字进行修改，不重复进行添加
print(dic) #{'age': 1000, 'height': 165, 'ability': '打妖怪', 'name': '孙悟空',
'teacher': '唐三藏', 'where': '花果山'}4.查找操作
| 字典的取值 | keys | 返回一个包含字典所有key的列表 |
|
| values | 返回一个包含字典所有vaule的列表 |
|
| get | 以键取值，如果指定键不存在，默认返回None,可以指定返回内容 |
|
| update | 以字典格式更新指定键的内容，如果键不存在，创建键和值 |
|
| items | 返回字典键值呈元组形式的格式 |
|
| len | 测量字典，键值对的个数（整体） |
dic={'height': 165, 'age': 1000, 'name': '孙悟空', 'where': '花果山'}
name=dic['name'] #根据关键字查找找内容
print(name) #孙悟空
name=dic.get('name') #根据键获取值
print(name) #孙悟空
name=dic.get('how') #
print(name) # 若关键字不存在返回None
dic={'height': 165, 'age': 1000, 'name': '孙悟空', 'where': '花果山'}
key=dic.keys() #获取所有key键
print(key) #dict_keys(['height', 'age', 'name', 'where'])
print(type(key)) #<class 'dict_keys'>
value=dic.values() #获取值
print(value) #dict_values([1000, '花果山', '孙悟空', 165])
print(type(value)) #<class 'dict_values'>
item=dic.items() #把字典中的键值转换成元组
print(item) #dict_items([('where', '花果山'), ('height', 165), ('age', 1000), ('name', '孙悟空')])
print(type(item)) #<class 'dict_items'>
print(len(dic)) #4| 字典的遍历字典的判断 | in | 判断指定的键是否在字典当中，即将被废除，之后我们python3用in |
|
| for ...in ... | 通过for ... in ...:的语法结构，我们可以遍历字符串、列表、元组、字典等数据结构。
|
|
| not in | 判断指定的键是否不在字典当中 |
in
dic={'height': 165, 'age': 1000, 'name': '孙悟空', 'where': '花果山'}
if 'name' in dic: #判断name(即关键字）是否在字典中
print("xx") #在输出xx
else:
print('nono') #不在输出nono
not in
dic={'height': 165, 'age': 1000, 'name': '孙悟空', 'where': '花果山'}
if 'name' in dic: #判断name(即关键字）是否在字典中
print("xx") #不在在输出xx
else:
print('nono') #在输出nono
for in
dic={'height': 165, 'age': 1000, 'name': '孙悟空', 'where': '花果山'}
for key in dic:
print(key) #输出关键字
for key in dic.keys():
print(key)
输出：
height
name
where
age
dic={'height': 165, 'age': 1000, 'name': '孙悟空', 'where': '花果山'}
for value in dic.values():
print(value) #获取关键字的值
输出：
165
1000
孙悟空
花果山
dic={'height': 165, 'age': 1000, 'name': '孙悟空', 'where': '花果山'}
for item in dic.items(): #获取所有键值对，以元组的形式返回
print(item)
输出：
('name', '孙悟空')
('where', '花果山')
('height', 165)
('age', 1000)
for key,value in dic.items():
print(key,value)
输出：
height 165
name 孙悟空
age 1000
where 花果山五，集合
1.添加操作
Add()、update()
set={'a',2,'寒冰'}
set.add('猪猪侠') #添加
print(set) #{'猪猪侠', 2, '寒冰', 'a'}
set={'a',2,'寒冰'}
set.update('霍雨浩','王冬') #分离成每个字符
print(set) #{2, '雨', '寒冰', '浩', '霍', 'a', '王', '冬'}
set={'a',2,'寒冰'}
set.update('ac','cd') #自动消除重复的
print(set) #{'a', 2, 'c', '寒冰', 'd'}
set={'a',2,'寒冰'}
set2={'ac','cd'} #集合里添加集合
set.update(set2)
print(set) # {'ac', 2, 'cd', 'a', '寒冰'} 2.删除操作
pop、remove、clear、del
set={'唐三','沐白','朱竹青','奥斯卡'}
set.pop() #随机删一个
print(set) #{'唐三', '奥斯卡', '朱竹青'}
set={'唐三','沐白','朱竹青','奥斯卡','猪八戒'}
set.remove('猪八戒') #指定删除
print(set) #{'朱竹青', '唐三', '沐白', '奥斯卡'}
set.clear() #清除集合内的内容
print(set) #set()= 集合
del set
print(set) #<class 'set'>3.遍历集合
set={'唐三',2,'朱竹青','奥斯卡','猪八戒','ac'}
for i in set:
print(i)
输出：
2
唐三
猪八戒
ac
奥斯卡
朱竹青4.关系：
- 交集（& 或者 intersection） 取公共部分
- 并集。(| 或者 union) 取去除重复部分内容
- 差集。(- 或者 difference)取set1或者set2中除去公共部分的内容
- 反交集。(^ 或者 symmetric_difference)
- 子集。(< 或者 issubset)
- 超集。(> 或者 issuperset)
set1={1,2,3,4,'a','f',2,'d',2,'e'}
set2={3,4,'q','e','g',7,9}
print(set1) #{1, 2, 3, 4, 'a', 'd', 'f', 'e'}
print(set2) #'g', 3, 4, 7, 9, 'q', 'e'}
print(set1&set2) #{3, 4, 'e'}
print(set1.intersection(set2)) #{'e', 3, 4} 交集
set1={1,2,3,4,'a','f','d','e'}
set2={3,4,'q','e','g',7,9} #并集
print(set1|set2) #{'q', 1, 2, 3, 4, 'd', 'g', 7, 'e', 9, 'f', 'a'}
print(set1.union(set2))#{'g', 1, 2, 3, 4, 7, 9, 'q', 'a', 'd', 'e', 'f'}
print(set1-set2) #{'a', 1, 2, 'd', 'f'} #差集
print(set1.difference(set2)) #{1, 2, 'a', 'd', 'f'}
print(set1^set2) #{1, 2, 7, 9, 'a', 'q', 'd', 'g', 'f'}
print(set1.symmetric_difference(set2)) #{1, 2, 'f', 'g', 7, 9, 'd', 'q', 'a'}
set1={1,2,3,4,5,'a','d'}
set2={1,2,3,'a'}
print(set1<set2) #False 子集
print(set1.issubset(set2)) #False
print(set1>set2) #True 超集
print(set1.issuperset(set2)) #True
六，对比
| 数据类型比较 | 字符串 | 列表 | 元组 | 字典 |
| 是否有序 | 是 | 是 | 是 | 否 |
| 是否可修改 | 不 | 可 | 不 | 可 |
| 方法多少 | 很多 | 一般 | 很少 | 较多 |
扫一扫
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
