本篇文章记录的是Python基础数据类型补充以及内置方法的知识。

一、引入

之前我们已经对python基础数据类型有了一个简单的认识，比如有字符串，布尔值，列表，元组，集合，字典等，但是那些都是基础的了解，对于基础数据类型我们还要进一步的学习他们，以及他们常用的内置方法。

二、数字类型

1、定义

age = 18 

# 实际上这是python的字面量语法,内部调用的是age=int(10)
# 先是在堆区中申请一块内存空间,把10存进去,然后把内存地址绑定给栈区的变量名.

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）进制转换

十进制转其他进制
==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'> 

（3）内置方法

int和float没有需要掌握的内置方法，他们的使用就是数学运算+比较运算。

三、字符串类型

1、定义

msg = 'hello'   # msg = str('hello')
print(msg)       # hello

2、类型转换

（1）str可以把任意其他类型都转成字符串

# 数字 --> str
num = 1234
res1 = str(num)
print(res1)     # '1234' <class 'str'>

# 列表 --> str
lst = ['tom',1234,['999',250],'shuaibi']
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、内置方法

（1）按照索引取值（正向取，反向取）只能取

msg = "lxx love npy"

# 正向取
print(msg[0])
print(msg[5])

# 反向取
print(msg[-1])

#只能取
msg[0] = "H"  # 报错

（2）切片

索引的拓展应用，从一个大字符串中拷贝出一个字符串（顾头不顾尾，步长）

msg = "lxx love npy"
# 顾头不顾尾
res9 = msg[0:3] # lxx

（3）步长

msg = "xyg love npy"
res = msg[0:7:2] # 0 2 4 6
print(res) # 

（4）反向步长

msg = "lxx love npy"
res = msg[0:7:-1]
print(res)   # 空,原因是切片和步长的方向不一致

res = msg[7:0:-1]
print(res)   # 

（5）通过切片拷贝字符串

msg = "lxx love npy"
msg1 = msg[0:13]
print(msg1)    # 
msg2 = msg[:]  # 不写索引,默认开头:结束
print(msg2)    # 

（6）把字符串倒过来

#  把字符串倒过来
msg = "lxx love npy"
msg1 = msg[::-1]
print(msg1)     # 'ypn evol xxl'

（7）长度len

msg = "lxx love npy"
print(len(msg))   # 12

（8）成员运算in和not in

# 成员运算in和not in
# 判断一个子字符串是否存在于一个大字符串中
msg = "lxx love npy"

print("ymn" in msg)  # False
print("sb" not in msg)  # True

（9）移除自付出啊左右两侧的符号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

（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:男']

（10）大小写转换lower upper

msg = 'aaaBBccDD'
print(msg.lower())  # aaabbccdd,大写转小写
print(msg.upper())  # AAABBCCDD,小写转大写

（11）startswith endswith

msg = 'aaaBBccDD'
print(msg.lower())  # aaabbccdd,大写转小写
print(msg.upper())  # AAABBCCDD,小写转大写

（12）format的三种方式

m = "lxx"
n = "npy"
print('{} love {}'.format(m, n))
print('{0} love {1}'.format(m, n))
print('{m} love {n}'.format(m=m, n=n))

（13）join拼接

# "拼接符".join(列表/字符串) , 这也是将列表转化为字符串的方式

lst = ['ymn','21','男']
print(':'.join(lst))  # ymn:21:男

msg = 'ymn'
print('nb'.join(msg)) # ynbmnbnnb

（14）replace替换

msg = "**ymn**"
new_msg = msg.replace('*','=') # replace(待替换的字符,替换成的字符,替换次数(默认所有))
print(new_msg)  # '==ymn=='

（15）isdigit

# 判断字符串是否全部由数字组成
print('123'.isdigit())  # True
print('12.3'.isdigit()) # False

（16）find index

都是通过字符查找索引，但是find找不到返回-1，index则报错

msg = "lxx love npy"
print(msg.find("n"))  # 返回要查找的字符串在大字符串中的起始索引 9

print(msg.find("npy"))  # 9
print(msg.find("s"))  # -1

# index
print(msg.index("s"))  # 报错

（17）count计数

# 统计小字符串在大字符串中出现的次数
msg = 'lxx love npy'
print(msg.count('l'))  # 2
print(msg.count('lxx'))  # 1
print(msg.count('s'))  # 0

（18）encode decode

编码和解码，byte类型 字节

# 字符串-->byte类型

# 字符串编码
s1 = "你好"
# res1 = s1.encode("utf-8")
res1 = s1.encode("gbk")
print(res1, type(res1))  # b'\xe4\xbd\xa0\xe5\xa5\xbd' <class 'bytes'>
                        # b'\xc4\xe3\xba\xc3' <class 'bytes'>

# 字符串解码
b1 = b'\xe4\xbd\xa0\xe5\xa5\xbd'
res1 = b1.decode("utf-8")
print(res1)  #

b2 = b'\xc4\xe3\xba\xc3'
res2 = b2.decode("gbk")
print(res2)  #

（19）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填充

（20）expandtabs(了解)

# 设置制表符代表的空格数
msg = 'ymn\tnb'
print(msg.expandtabs(2))  # 'ymn  nb'

（21）captalize swapcase title (了解)

print('ymn'.capitalize())        # Ymn    字符串首字母大写
print('ymn NB'.swapcase())  # YMN nb 字符串大小写翻转
print('ymn nb'.title())            # Ymn Nb 每个单词首字母大写

（22） is系列(了解)

# 判断字符串是否是全小写字母组成
print('ymn'.islower()) 

# 判断字符串是否是全小写字母组成
print('YMN'.isupper())  

# 判断字符串的每个单词的首字母是否大写
print('lxx love npy'.istitle()) 

# 判断字符串是否由数字或字母组成
print('Ymn 666'.isalnum())  

# 判断字符串是否由字母组成
print('Ymn'.isalpha()) 

# 判断字符串是否由空格组成
print('    '.isspace())  

# 判断字符串是否符合标识符的命名规范
print('Ymn'.isidentifier())  

（23） 数字系列(了解)

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

四、列表类型

1、 定义

# 1.作用: 按位置存放多个值
# 2.定义: 在中括号中按照逗号分隔开,多个任意类型的值
l = [1, 2, 3, 'ymn']  # l = list([1,2,3,"ymn"])

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']

3、 内置方法

（1） 索引取值

按照索引存取值(正向/反向存取):即可以取也可以改

l = [1, 2, 3, 'ymn']
# 正向取
print(l[1])

# 反向取
print(l[-1])

# 可以取也可以改
# 索引存在则修改对应的值
l[2] = 999
print(l[2])

# 索引不存在,无论是取还是修改都会报错
l[5] = 555
print(l)

（2）切片(顾头不顾尾,步长)

l = [1, 2, 3, 'ymn']
print(l[0:3])   # [1,2,3]
print(l[:])     # 切片等同于拷贝行为,而且相当于浅拷贝
print(l[::-1])  # 列表倒序

（3）长度 len

l = [0,1,2,3,4]
print(len(l)) # 5

（4）成员运算符in和not in

l = ['lxx','love','npy']

print('mn' in l)
print('mn' not in l)

（5）append

追加 在列表的末尾追加值

l = [11,'ymn',666]
l.append(333)
print(l)   # [11,'ymn',666,333]

（6）insert 插入

当索引大于当前列表最大索引,默认插入到列表末尾

l = [11, 'ymn', 666]
# l.insert(1, 'tom')
# print(l)  # [11,'tom','ymn', 666]

# 需求: 把"jack"插入到l的最后一个位置,使用insert
# l.insert(-1, 'jack')
# print(l)

（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)

（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]

（9） for循环

谨记:循环只是为了读,尽量不要修改,否则会出现索引问题

for x in [1,2,3,4]:
    print(x)

（10） count( )

# 统计元素在列表中出现的次数
l = [11, 22, 11, 22, 'ymn']
print(l.count(11))  # 2

（11） index( )

# 返回元素在列表中首位索引
l = ['ymn',18]
print(l.index('ymn')) # 0
print(l.index('mn'))  # 找不到报错

（12）clear( )

# 清空列表
l = [1,2,3,4]
l.clear()
print(l)

（13） reverse( )

不是排序,就是把列表倒过来

l = [11, 22, 11, 22, 'ymn']
l.reverse()
print(l)  # ['ymn',22,11,22,11]

（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

（15） enumerate

enumerate 是一个内置函数 , 参数是一个可迭代对象 , 即可以for的数据类型 , 循环返回索引和值

for i,v in enumerate(["tom","18","喝酒"]):
    print(i,v)

五、 元组类型

元组就是"一个不可变的列表"

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,)  # 如果元组中只有一个元素,必须加逗号

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

3、 类型转换

只要是可以被for循环的数据类型都可以被tuple强制转换成元组

print(tuple('hello'))      # ('h','e','l','l',o)
print(tuple(['hello']))    # ("hello",)
print(tuple({'hello':1}))  # ("hello",)

4、 常用和内置方法

（1） 索引取值

# 按照索引存取值(正向/反向存取):只能取
t = (1, 2, 3, 'ymn')
# 正向取
print(t[1])   # 2

# 反向取
print(t[-1])  # "ymn"

（2） 切片 (顾头不顾尾,步长)

t = (1, 2, 3, 'ymn')
print(t[0:3])     # (1,2,3)
print(t[:])       # 切片等同于拷贝行为,而且相当于浅拷贝
print(t[::-1])    # 元祖倒叙

（3）长度 len

tu = (1,2,3,4)
print(len(tu))  # 4

（4）成员运算符in和not in

t = ('ymn',18,'男')
print('mn' in t)     # False
print('mn' not in t) # True

（5） 循环

t = (1, 2, 3, 'ymn')
for el in t:
    print(el)

（6） 内置方法

t = (1,2,3)
print(t.count(1))  # 1
print(t.index(1))  # 0

六、 字典类型

1、定义

{ }内用逗号分隔开多个key:value,其中value可以是任意类型,但是key必须是不可变的类型,且不能重复

dic = {"k1":1}     # dic = dict(k1=1})
print(dic)

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':'男'}

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)

4、内置方法

（1） 按照key存取值:可存可取

# 3.按照key(键)存取值:可存可取
d = {'k1':1}

# 取值
print(d["k1"])

# 针对赋值操作key存在,则修改
d['k1'] = 22
print(d)  # {"k1":22}

# 增加键值对
d['k2'] = 3
print(d)     # {'k1': 22, 'k2': 3}

（2） 长度 len

d = {'k1':1,'k2':2,'k3':3}
print(len(d))  # 3

（3）成员运算 in 和 not in: 根据key

d = {'k1':1,'k2':2,'k3':33}
print('k1' in d)
print('k1' not in d)

（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}

（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） 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)

（7）clear( )

# 清空字典
d = {'k1':1,'k2':2,'k3':33}
d.clear()
print(d)  # {}

（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}

（9） get( )

通过get(key),获取字典中key对应的值 ,不存在默认返回None

d = {'k1': 1, 'k2': 2, 'k3': 33}
print(d.get("k1"))

# 如果key不存在,默认返回None
# if not d.get("k111"):
#     print("k111 不存在")
#
# get 可以设置第二个参数
print(d.get("k111","不存在"))

（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}

七、 集合

1、 作用

集合是把一堆值集中在一起来做一个整体方面的操作 , 如关系运算,去重

如果你去关注把集合中的某一个元素取出来的话,就丧失了创建集合的初衷,你想取出单个值,那么你用列表或者元组就好了.

2、 定义

==在{ }内用逗号分隔开多个元素,多个元素满足以下三个条件==

1. 集合内元素必须是不可变类型
2. 集合内元素无序
3. 集合内元素没有重复

s1 = {1,2} # s1 = set(1,2)
print(s1)

补充 :

s = {} # 默认是空字典
print(s,type(s))  # {} <class dict>
# 定义空集合
s = set()
print(s,type(s))  # {} <class 'set'>

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)

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'}

（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'}

（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'}

（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'}

（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

5、 去重

虽然集合具有天然的去重性，但是也有一定的局限性，它只能适用于对顺序没有要求的去重。

# 1.只能针对不可变类型去重
print((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)

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)

（2） clear( )

# 清空集合
s1 = {1, 2, 3, 4, }
s1.clear()
print(s1)    # {}

（3） pop ( )

# 随机删除集合的一个元素
s1 = {1, 2, 3, 4, }
print(s1.pop())  # 2
print(s1)        # {1, 3, 4, }

（4） update ( )

# 更新集合
s1 = {1, 2, 3, 4, }
s1.update({4,5,6,8})
print(s1)           # {1, 2, 3, 4,5,6,8}

（5） add ( )

# 增加新值
s1 = {1, 2, 3, 4, }
s1.add('ymn')
print(s1)     # {1,'ymn', 2, 3, 4, }

（6） isdisjoint ( )

# 判断两个集合是否相互独立,即不存在交集
print({1,2,3}.isdisjoint({4,5,6}))  # True

八、 总结