python基础数据类型补充及内置方法
1.引入
之前我们已经对python基础数据类型有了一个简单的认识，比如有字符串，布尔值，列表，元组，字典等。但是
那些都是基础的了解，对于基础数据类型我们还要进一步的学习他们，以及他们常用的内置方法。
2. 数字类型
2.1 定义
age = 18
# 实际上这是python的字面量语法,内部调用的是age=int(10)
# 先是在堆区中申请一块内存空间,把10存进去,然后把内存地址绑定给栈区的变量名.
2.2 类型转换
2.2.1 字符串转数字
int可以将由纯整数构成的字符串直接转换成整型，若包含其他任意非整数符号，则会报错。
s = '1234'
ret = int(s)
print(ret,type(ret)) # 1234 <class 'int'>
int('13.14') # 错误演示：字符串内包含了非整数符号.
Traceback (most recent call last):
File "<stdin>", line 1, in <module>
ValueError: invalid literal for int() with base 10: '13.14'
2.2.2 进制转换
十进制转其他进制
10进制 ---> 2进制
res1 = bin(11)
print(res1) # 0b1011
10进制 ---> 8进制
res2 = oct(11)
print(res2) # 0o13
10进制 ---> 16进制
res3 = hex(11)
print(res3) # 0xb
其他进制转10进制
2进制 ---> 10进制
res4 = int('11', base=2)
print(res4) # 3
8进制 ---> 10进制
res5 = int('13', base=8)
print(res5) # 11
16进制 ---> 10进制
res6 = int('b', base=16)
print(res6) # 11
关于float类型你了解一个类型转换，目前就可以了。
res7 = float("3.14115926")
print(res7,type(res7)) # 3.14115926 <class 'float'>
2.3 内置方法
int和float没有需要掌握的内置方法，他们的使用就是数学运算+比较运算。
3. 字符串类型
3.1 定义
msg = 'hello' # msg = str('hello')
print(msg) # hello
3.2 类型转换
3.2.1 str可以把任意其他类型都转成字符串
是不是很快牛逼，是真是假，我们一探究竟。
# 数字 --> str
num = 1234
res1 = str(num)
print(res1) # '1234' <class 'str'>
# 列表 --> str
lst = ['tom',1234,['999',250],'shabi']
res2 = str(lst)
print(res2,type(res2)) # ['tom',1234,['999',250],'shabi'] <class 'str'>
# 字典 --> str
dic = {'name':'ymn'}
res3 = str(dic)
print(res3,type(res3)) # {'name':'ymn'} <class 'str'>
3.3 内置方法
3.3.1 按照索引取值(正向取,反向取) 只能取
msg = "ymn love xcy"
# 正向取
print(msg[0])
print(msg[5])
# 反向取
print(msg[-1])
#只能取
msg[0] = "H" # 报错
3.3.2 切片
索引的拓展应用,从一个大字符串中拷贝出一个字符串 (顾头不顾尾,步长)
msg = "ymn love xcy"
# 顾头不顾尾
res9 = msg[0:3] # ymn
3.3.3 步长
msg = "ymn love xcy"
res = msg[0:7:2] # 0 2 4 6
print(res) # ynlv
3.3.4 反向步长
msg = "ymn love xcy"
res = msg[0:7:-1]
print(res) # 空,原因是切片和步长的方向不一致
res = msg[7:0:-1]
print(res) # evol nm
3.3.5 通过切片拷贝字符串
msg = "ymn love xcy"
msg1 = msg[0:13]
print(msg1) # "ymn love xcy"
msg2 = msg[:] # 不写索引,默认开头:结束
print(msg2) # "ymn love xcy"
3.3.6 把字符串倒过来
msg = "ymn love xcy"
msg1 = msg[::-1]
print(msg1) # 'ycx evol nmy'
3.3.7 长度len
msg = "ymn love xcy"
print(len(msg)) # 12
3.3.8 成员运算in和not in
# 判断一个子字符串是否存在于一个大字符串中
msg = "ymn love xcy"
print("ymn" in msg) # True
print("sb" not in msg) # True
3.3.8 移除字符串左右两侧的符号strip
# 默认去掉空格
name = " ymn "
new_name = name.strip()
print(name) # 不会改变原值 " ymn "
print(new_name) # 是产生了新值 'ymn'
# 指定去除符号
msg = "***有猫腻***"
new_msg = msg.strip("*")
print(new_msg) # 有猫腻
了解: strip只去除两边的，不会去除中间的
因为strip内部是先从字符串的左边开始一一比较是不是要去除的符号,如果是就去除,然后继续比较
如果不是就会从字符串的右侧开始一一比较是不是要去除的符号,直到不是要去除的符号,然后停止比较
返回去除后的新值。
# strip可以设置多个去除符号
msg = "*()-=ymn+++*&^"
new_msg = msg.strip("*()-+=&^")
print(new_msg) # ymn
补充: lstrip rstrip
msg = "***ymn***"
print(msg.strip("*")) # ymn
print(msg.lstrip("*")) # ymn***,只去除左边
print(msg.rstrip("*")) # ***ymn,只去除右边
3.3.9 分割split
把字符串按照某种分割符进行切分,得到一个列表
info = "ymn 20 男"
# 默认按照空格分割
lst = info.split()
print(lst) # ['ymn','20','男']
# 指定分隔符
info = "ymn:20:男"
lst = info.split(":")
print(lst) # ['ymn','20','男']
# 指定分割的次数,默认是全部分割
info = "ymn:20:男"
lst = info.split(":", 1)
print(lst) # ['ymn','20:男']
补充 : split rsplit
# 默认切分是从左到右,rsplit是从右向左,只有当指定分割次数的他们两个的区分才能看出啦
msg = 'ymn:男:21'
print(msg.split(':',1)) # ['ymn', '男:21']
print(msg.rsplit(":",1)) # ['ymn:男', '21']
3.3.10 大小写转换 lower upper
msg = 'aaaBBccDD'
print(msg.lower()) # aaabbccdd,大写转小写
print(msg.upper()) # AAABBCCDD,小写转大写
3.3.11 startswith endswith
msg = 'ymn love xcy'
print(msg.startswith('ymn')) # 判断是否以什么开头
print(msg.endswith('xcy')) # 判断是否以什么结尾
3.3.12 formate的三种方式
3.3.13 join拼接
# "拼接符".join(列表/字符串),这也是将列表转化为字符串的方式
lst = ['ymn','21','男']
print(':'.join(lst)) # ymn:21:男
msg = 'ymn'
print('nb'.join(msg)) # ynbmnbnnb
3.3.14 replace 替换
msg = "**ymn**"
new_msg = msg.replace('*','=') # replace(待替换的字符,替换成的字符,替换次数(默认所有))
print(new_msg) # '==ymn=='
3.3.15 isdigit
# 判断字符串是否全部由数字组成
print('123'.isdigit()) # True
print('12.3'.isdigit()) # False
3.3.16 find index
都是通过字符查找索引,但是find找不到返回-1,index则报错
msg = "ymn love xcy"
print(msg.find("n")) # 返回要查找的字符串在大字符串中的起始索引
print(msg.find("xcy"))
print(msg.index("n")) # 返回要查找的字符串在大字符串中的起始索引
print(msg.index("xcy"))
print(msg.find('alex')) # 返回-1,代表找不到
print(msg.index('alex')) # 找不到,报错
3.3.17 count 计数
# 统计小字符串在大字符串中出现的次数
msg = 'ymn love xcy'
print(msg.count('y')) # 2
print(msg.count('ymn')) # 1
3.3.17 center,ljus,rjust,zfill 控制输出的
print('ymn'.center(20, '*')) # 显示宽度为20,居中,不够的用"*"填充
print('ymn'.ljust(20, '*')) # 显示宽度为20,左对齐,不够的用"*"填充
print('ymn'.rjust(20, '*')) # 显示宽度为20,右对齐,不够的用"*"填充
print('ymn'.zfill(20)) # 显示宽度为20,用0填充
3.3.18 expandtabs
# 设置制表符代表的空格数
msg = 'ymn nb'
print(msg.expandtabs(2)) # 'ymn nb'
3.3.19 captalize swapcase title
print('ymn'.capitalize()) # Ymn 字符串首字母大写
print('ymn NB'.swapcase()) # YMN nb 字符串大小写翻转
print('ymn nb'.title()) # Ymn Nb 每个单词首字母大写
3.3.20 is系列
# 判断字符串是否是全小写字母组成
print('ymn'.islower())
# 判断字符串是否是全小写字母组成
print('YMN'.isupper())
# 判断字符串的每个单词的首字母是否大写
print('Ymn love xcy'.istitle())
# 判断字符串是否由数字或字母组成
print('Ymn 666'.isalnum())
# 判断字符串是否由字母组成
print('Ymn'.isalpha())
# 判断字符串是否由空格组成
print(' '.isspace())
# 判断字符串是否符合标识符的命名规范
print('Ymn'.isidentifier())
3.3.21 数字系列
num1 = b'4' # bytes
num2 = u'4' # unicode,python3中无需加u就是unicode
num3 = '四' # 中文数字
num4 = 'Ⅳ' # 罗马数字
# isdigit只能识别:num1,num2
print(num1.isdigit()) # True
print(num2.isdigit()) # True
print(num3.isdigit()) # False
print(num4.isdigit()) # False
# isnumeric可以识别:num2,num3,num4 (银行收款)
print(num2.isnumeric()) # True
print(num3.isnumeric()) # True
print(num4.isnumeric()) # True
# isdecimal只能识别:num2
print(num2.isdecimal()) # True
print(num3.isdecimal()) # False
print(num4.isdecimal()) # False
4. 列表类型
4.1 定义
# 1.作用: 按位置存放多个值
# 2.定义: 在中括号中按照逗号分隔开,多个任意类型的值
l = [1, 2, 3, 'ymn'] # l = list([1,2,3,"ymn"])
4.2 类型转换
但凡能够被for循环遍历的类型都可以当做参数传给list( )转成列表
res = list("hello") # list底层做的就是for循环那个参数,然后把每个值都放到列表中
print(res) # ['h','e','l','l','o']
res1 = list({'k1':1,'k2':2})
print(res1) # ['k1','k2']
4.3 内置方法
4.3.1 索引取值
按照索引存取值(正向/反向存取):即可以取也可以改
l = [1, 2, 3, 'ymn']
# 正向取
print(l[1])
# 反向取
print(l[-1])
# 可以取也可以改
# 索引存在则修改对应的值
l[2] = 999
print(l[2])
# 索引不存在,无论是取还是修改都会报错
l[5] = 555
print(l)
4.3.2 切片(顾头不顾尾,步长)
l = [1, 2, 3, 'ymn']
print(l[0:3]) # [1,2,3]
print(l[:]) # 切片等同于拷贝行为,而且相当于浅拷贝
print(l[::-1]) # 列表倒序
4.3.3 长度 len
l = [0,1,2,3,4]
print(len(l)) # 5
4.3.4 成员运算符in和not in
l = ['ymn','love','xcy']
print('mn' in l)
print('mn' not in l)
4.3.5 append
追加 在列表的末尾追加值
l = [11,'ymn',666]
l.append(333)
print(l) # [11,'ymn',666,333]
4.3.6 insert 插入
当索引大于当前列表最大索引,默认插入到列表末尾
l = [11, 'ymn', 666]
l.insert(1, 'alex')
print(l) # [11,'alex','ymn', 666]
l.insert(-1,'wusir') # 如果索引是负的,那么追加的值的位置是向左偏移一个单位.
print(l) # [11, 'ymn', 'wusir', 666]
4.3.7 extend 迭代添加
l = [11, 'ymn', 666]
l1 = [99,88,77]
l.extend(l1)
print(l) # [11, 'ymn', 666,99,88,77]
# 内部实现
for el in l1:
l.append(el)
print(l)
4.3.8 删除
# 方式1: del 通用的删除方法,没有返回值
l = [11, 'ymn', 666]
del l[1]
x = del l[1] # 抛出异常,不支持赋值语法
print(l)
# 方式二:l.pop() 根据索引删除,会返回删除的值
l = [11, 'ymn', 666]
res = l.pop() # 不指定索引默认删除最后一个
print(res) # 666
print(l) # [11, 'ymn', 666]
# 方式三:l.remove() 根据元素删除,返回None
l = [11, 'ymn', 666]
l.remove('ymn')
print(l) # [11, 666]
4.3.9 for循环
谨记:循环只是为了读,尽量不要修改,否则会出现索引问题
for x in [1,2,3,4]:
print(x)
4.3.10 count( )
# 统计元素在列表中出现的次数
l = [11, 22, 11, 22, 'ymn']
print(l.count(11)) # 2
4.3.11 index( )
# 返回元素在列表中首位索引
l = ['ymn',18]
print(l.index('ymn')) # 0
print(l.index('mn')) # 找不到报错
4.3.12 clear( )
# 清空列表
l = [1,2,3,4]
l.clear()
print(l)
4.3.13 reverse( )
不是排序,就是把列表倒过来
l = [11, 22, 11, 22, 'ymn']
l.reverse()
print(l) # ['ymn',22,11,22,11]
4.3.14 sort( )
列表内的元素必须是同种类型才可以排序
l = ['ymn','123','haha'] # 字符串比大小,按照对应的位置的字符依次pk,一旦有结果就停止pk,字符串的大小按照ASCII码表的先后顺序区别字符大小
l.sort() # 默认从小到大排,升序
print(l) # ['123', 'haha', 'ymn']
l.sort(reverse=True) # 从大到小,降序
print(l) # ['ymn', 'haha', '123']
print('a' > "A") # True
# 了解:列表也可以比大小,原理同字符串一样,对应位置必须是同种类型,否则报错
l = [11,22,33,44]
l1 = [12]
print(l < l1) # True
4.3.15 补充:队列,堆栈 两种数据结构 就是用来存取值的
# 队列:FIFO,先进先出
l = []
# 入队操作
l.append('1')
l.append('2')
l.append('3')
print(l)
# 出队操作
print(l.pop(0))
print(l.pop(0))
print(l.pop(0))
# 堆栈:LIFO,后进先出
l = []
# 入栈操作
l.append('1')
l.append('2')
l.append('3')
print(l)
# 出栈操作
print(l.pop())
print(l.pop())
print(l.pop())
5. 元组类型
元组就是"一个不可变的列表"
5.1 定义
# 1.作用: 按照索引(位置)存放多个值,只用于读不用于改
# 2.定义: ()内用逗号分隔开多个任意类型的元素
t = (1,2,3) # t = tupte(1,2,3)
print(t,type(t)) # (1,2,3) <class tuple>
x = (10) # 单独一个括号代表包含的意思
print(x,type(x)) # 10 <class int>
tu = (10,) # 如果元组中只有一个元素,必须加逗号
5.2 探秘元组的不可变
t = (11,22,'aa',[11,22])
print(id(t(3))) # 75438567785467
# t = (0->值1的内存地址,1->值22的内存地址,2->值"aa"的内存地址)
# 元组在内存中存的是索引和值的内存地址,说元素不可变,就是当元祖在内存中创建好了,那么索引对应的内存地址就不能改变了,换句话说,当元祖中的索引对应的内存地址没有发生改变,那么元组就没有改变
t(1) = 99 # 不能改,报错
t(3)(1) = 99
print(t) # (11, ,22, 'aa', [11, 99]) 因为索引3对应的值是可变类型的数据,
# 我们只是对他的内部元素进行了修改,但是元祖中这个索引对应的内存地址并没有,所以元组并没有发生改变
print(id(t(3))) # 75438567785467
5.3 类型转换
只要是可以被for循环的数据类型都可以被tuple强制转换成元组
print(tupte('hello')) # ('h','e','l','l',o)
print(tupte(['hello'])) # ("hello",)
print(tupte({'hello':1})) # ("hello",)
5.4 常用和内置方法
5.4.1 索引取值
# 按照索引存取值(正向/反向存取):只能取
t = (1, 2, 3, 'ymn')
# 正向取
print(t(1)) # 2
# 反向取
print(t(-1)) # "ymn"
5.4.2 切片 (顾头不顾尾,步长)
t = (1, 2, 3, 'ymn')
print(t(0:3)) # (1,2,3)
print(t(:)) # 切片等同于拷贝行为,而且相当于浅拷贝
print(t(::-1)) # 元祖倒叙
5.4.3 长度 len
tu = (1,2,3,4)
print(len(tu)) # 4
5.4.4 成员运算符in和not in
t = ('ymn',18,'男')
print('mn' in t) # False
print('mn' not in t) # True
5.4.5 循环
t = (1, 2, 3, 'ymn')
for el in t:
print(el)
5.4.6 内置方法
t = (1,2,3)
print(t.count(1)) # 1
print(t.index(1)) # 0
6. 字典类型
6.1 定义
{ }内用逗号分隔开多个key:value,其中value可以是任意类型,但是key必须是不可变的类型,且不能重复
dic = {"k1":1} # dic = dict(k1=1})
print(dic)
6.2 类型转换
info = [
['name','ymn'],
['age',18],
['gender',"男"],
]
d = {}
for k,v in info:
d[k] = v
print(d) # {"name":'ymn','age':18,'gender':'男'}
res = dict(info) # 一行代码解决,实际上内部做的就是上面的for循环,前提是子元素必须是有两个值
print(res) # {"name":'ymn','age':18,'gender':'男'}
6.3 初始化字典
即字典的key对应的值为None
# 1.直接手写
d = {'k1':None,'k2':None,'k3':None}
# 2.循环增加
keys = ['k1','k2','k3']
d = {}
for key in keys:
d[key] = None
print(d)
# 3.利用内置的fromkeys方法
d1 = dict.fromkeys(keys,None) # 内部就是上面的for循环
print(d1)
6.4 内置方法
6.4.1 按照key存取值:可存可取
d = {'k1':1}
# 针对赋值操作key存在,则修改
d['k1'] = 22
print(d) # {"k1":22}
# 针对赋值操作key不存在,则创建新值(有则修改,无则增加)
d['k2'] = 333
print(d) # {'k1':22,'k2':333}
6.4.2 长度 len
d = {'k1':1,'k2':2,'k3':3}
print(len(d)) # 3
6.4.3.成员运算 in 和 not in: 根据key
d = {'k1':1,'k2':2,'k3':33}
print('k1' in d)
print('k1' not in d)
6.4.4 删除
# 4.1通用删除
d = {'k1':1,'k2':2,'k3':33}
del d['k1']
print(d) # {'k2':2,'k3':33}
# 4.2 pop删除: 根据key删除元素,返回删除key对应的value值
d = {'k1':1,'k2':2,'k3':33}
print(d.pop('k2')) # 2
print(d) # {'k1':1,'k3':33}
# 4.3 popitem删除: 随机删除,返回一个元组(删除的key,value)
d = {'k1':1,'k2':2,'k3':33}
res = d.popitem()
print(res) # ('k3',33)
print(d) # {'k1':1,'k2':2}
6.4.5 键keys( ) 值values( ) 键值对items( )
d = {'k1':1,'k2':2,'k3':33}
print(d.keys(),type(d.keys())) # dict_keys(['k1', 'k2', 'k3']) <class 'dict_keys'>
print(d.values()) # dict_values([1, 2, 33])
print(d.items()) # dict_items([('k1', 1), ('k2', 2), ('k3', 33)])
6.4.6 for循环
d = {'k1':1,'k2':2,'k3':33}
for key in d.keys():
print(key)
for k in d:
print(k)
for v in d.values():
print(v)
for k,v in d.items():
print(k,v)
6.4.7 clear( )
# 清空字典
d = {'k1':1,'k2':2,'k3':33}
d.clear()
print(d) # {}
6.4.8 update( )
更新字典,用新字典更新老字典,一切以新字典为准
d = {'k1':1,'k2':2,'k3':33}
d.update({'k1':99,'k4':44})
print(d) # {'k1':99,'k2':2,'k3':33,'k4':44}
6.4.9 get( )
通过get(key),获取字典中key对应的值 ,不存在默认返回None
d = {'k1':1,'k2':2,'k3':33}
print(d.get('k1')) # 1
print(d.get('k5')) # None
6.4.10 setdefault( )
d = {'k1':1,'k2':2,'k3':33}
# 4.1 如果key存在,就不修改原值,返回字典中key对应的值
print(d.setdefault('k1',444)) # 1
print(d) # {'k1':1,'k2':2,'k3':33}
# 4.2 如果key不在,增加新值,返回字典中key对应的值
print(d.setdefault('k4',4444)) # 4444
print(d) # {'k1':1,'k2':2,'k3':33,'k4':4444}
7. 集合
7.1 作用
集合是把一堆值集中在一起来做一个整体方面的操作,如关系运算,去重
如果你去关注把集合中的某一个元素取出来的话,就丧失了创建集合的初衷,你想取出单个值,那么你用列表或者元组就好了.
7.2 定义
在{ }内用逗号分隔开多个元素,多个元素满足以下三个条件
- 集合内元素必须是不可变类型
- 集合内元素无序
- 集合内元素没有重复
s1 = {1,2} # s1 = set(1,2)
print(s1)
补充 :
s = {} # 默认是空字典
print(s,type(s)) # {} <class dict>
# 定义空集合
s = set()
print(s,type(s)) # {} <class 'set'>
7.3 类型转换
s = set({1,2,3}) # 内部和list,tuple一样都是调用的for循环
print(s)
s = set("hello")
print(s)
s = set([1,2,3,[1,2,3],2]) # 报错,因为元素中存在了可变的数据类型
print(s)
s = set({'k1':1,'k2':2}) # 只把key添加到集合中
print(s)
7.4 关系运算
7.4.1 交集 &/intersection
friend1 = {'ymn', 'tom', 'fangfang', 'jack'}
friend2 = {'ymn', 'benben', 'niuniu', 'jack'}
res = friend1 & friend2
print(res) # {'ymn','jack'}
print(friend1.intersection(friend2)) # {'ymn','jack'}
7.4.2 并（合）集 |/union
friend1 = {'ymn', 'tom', 'fangfang', 'jack'}
friend2 = {'ymn', 'benben', 'niuniu', 'jack'}
res = friend1 | friend2 # {'ymn', 'benben','tom', 'fangfang', 'niuniu', 'jack'}
print(friend1.union(friend2))# {'ymn','benben','tom','fangfang','niuniu', 'jack'}
7.4.3 差集 -/difference
friend1 = {'ymn', 'tom', 'fangfang', 'jack'}
friend2 = {'ymn', 'benben', 'niuniu', 'jack'}
# 取friend1独有的好友
res = friend1 - friend2
print(res) # {'tom', 'fangfang'}
print(friend1.difference(friend2))# {'tom', 'fangfang'}
# 取friend2独有的好友
res = friend2 - friend1
print(res) # {'benben', 'niuniu'}
7.4.4 对称差集 ^/symmetric_difference
friend1 = {'ymn', 'tom', 'fangfang', 'jack'}
friend2 = {'ymn', 'benben', 'niuniu', 'jack'}
# 取两个用户独有的好友(即去掉公共的好友)
print((friend1 - friend2) | (friend2 - friend1))
# {'tom','fangfang','benben','niuniu'}
print(friend1 ^ friend2) # {'tom','fangfang','benben','niuniu'}
print(friend1.symmetric_difference(friend2))
# {'tom','fangfang','benben','niuniu'}
7.4.5 父子集 包含关系
s1 = {1, 2, 3, 4, }
s2 = {1, 2, 5}
# 不存在包含关系,下面比较均为False
print(s1 > s2) # False
print(s1.issuperset(s2)) # False
print(s1 < s2) # False
print(s1.issubset(s2)) # False
s1 = {1, 2, 3, 4, }
s2 = {1, 2, 3}
print(s1 > s2) # True 当s1大于或等于s2时,才能说s1是s2他爹
s1 = {1, 2, 3}
s2 = {1, 2, 3}
print(s1 == s2) # True s1和s2互为父子集
print(s1.issuperset(s2)) # True
print(s2.issuperset(s1)) # True
7.5 去重
虽然集合具有天然的去重性，但是也有一定的局限性，它只能适用于对顺序没有要求的去重。
# 1.只能针对不可变类型去重
print(list(set([1,2,1,2,1,3])))
# 2.无法保证原来的顺序
print(list(set(['a',1,2,3,1,'a','ymn'])))
# 通常我们用成员运算也能达到去重的效果
# 小练习:去重
l = [
{'name':'ymn'},
{'name':'tom'},
{'name':'fangfang'},
{'name':'tom'},
]
new_l = []
for item in l:
if item not in new_l:
new_l.append(item)
print(new_l)
7.6 其他内置方法
7.6.1 删除
s1 = {1, 2, 3, 4, }
res = s1.discard(5) # 删除元素,不存在返回None
print(res) # None
print(s1) # {1, 2, 3, 4, }
res = s1.remove(5) # 删除元素,不存在报错
print(res)
print(s1)
7.6.2 clear( )
# 清空集合
s1 = {1, 2, 3, 4, }
s1.clear()
print(s1) # {}
7.6.3 pop ( )
# 随机删除集合的一个元素
s1 = {1, 2, 3, 4, }
print(s1.pop()) # 2
print(s1) # {1, 3, 4, }
7.6.4 update ( )
# 更新集合
s1 = {1, 2, 3, 4, }
s1.update({4,5,6,8})
print(s1) # {1, 2, 3, 4,5,6,8}
7.6.5 add ( )
# 增加新值
s1 = {1, 2, 3, 4, }
s1.add('ymn')
print(s1) # {1,'ymn', 2, 3, 4, }
7.6.6 isdisjoint ( )
# 判断两个集合是否相互独立,即不存在交集
print({1,2,3}.isdisjoint({4,5,6})) # True
8. 总结
| 按照存值的个数区分 | 类型 |
|---|---|
| 只存一个值,可以称为标量/原子类型 | 数字(int,float),字符串 |
| 存放多个值,可以成为容器类型 | 列表,元组,字典,集合 |
| 按照访问方式区分 | 类型 |
|---|---|
| 直接访问,只能通过变量名访问多个值 | 数字(int,float),集合 |
| 顺序访问,可以通过索引访问值,索引代表顺序,又称序列类型 | 字符串,列表,集合 |
| key访问,通过key访问值,又称映射类型 | 字典 |
| 按照可变不可变区分 | 类型 |
|---|---|
| 可变类型 | 列表,集合,字典 |
| 不可变类型 | 数字(int,float),元组,字符串 |