python基础数据类型

第三章 数据类型

1.bool（布尔值）

• True（真）和 False（假）

  布尔值就是用于表示真假，True和False

  其他类型转换成布尔值：

  None , " " , 0 ,[] ,{} ,() ,set() --->False，其他都是True

  None ：空，就是什么都没有，0，[]:空列表，{}：空字典，（）：空元组

  set():空集合

  强制转换：
  ​
  bool(整数)       ->    bool(1)/..                             -> bool(0)
  bool(字符串)    ->   bool('xx')                             --> bool("")
  bool(列表)        ->  bool([])                                 --> bool([])
  bool(元组)        -> bool(())                                 --> bool(空元组)
  ​

  v1 = bool(0) v5 = bool({})
  v2 = bool("")  v6= bool(set())
  v3 = bool([])
  v4 = bool(())
  print(v1,v2,v3,v4，v5,v6) # False
  ​

   

2. int（整型）

2.1整形的长度

py2中有：int/long（长整型）

py3中只有：int

2.2整除

py2中：整除只保留整位数

或者加一行：from_future_importdivision,就可以保留所有。

py3中则是正常的保留所有

强制转换：int(''76")，需要掌握字符串转数字*，和数字转字符串

强制转换

• int('字符串')【重要】

• int('布尔值')

  • int(True)== 1，int(False) ==0

3. 字符串

3.1 定义：凡是用引号引起来的数据就称之为字符串

字符串是代码中最常见的，python内存中字符串是按照Unicode编码存储的。

对于字符串是不可变的，所以字符串不可以删除和修改。

字符串（str）

• 单引号

• 双引号

• 三引号（一般用作注释）

3.2 字符串独有方法【常用】

• .upper() / .lower()：大 / 小写

• .isdigit()：判断字符串是否可转换为数字

• .strip() ：两边空格去掉/ .lstrip()：去左边 / .rstrip()：去掉右边的空格

• .replace（‘被替换的字符/子序’，‘d要替换为的内容’） /.replace（”被替换的字符/子序列“，”要替换的内容“，1）从左到右

• .split（’根据什么东西进行分割‘）/.split（’根据什么东西分割‘，1）/.rsplit从左到右

• isdecimal() 判断是否是 10进制的数

# ############## 应用 ##############
​
v = ['alex','eric','tony']
​
for i in v:
    print(i)
​
num = input('请输入序号：')
if num.isdecimal():
    num = int(num)
    print(v[num])
else:
   print('你输入的不是数字')
​

 

• strip()【去空白】/lstrip()去左边/rstrip()去右边

name = ' alex '
new_name = name.strip()
print(new_name)
​

• replace()【替换,可以加参数】

msg = 'alex 很nb,alex是老男孩教育的创始人之一，alex长得很帅'
msg1 = msg.replace('太白')
msg2 = msg。replace('太白'，2)
​

• upper()/lower()

name = 'alex'
new_name = name.upper()
print(new_name)
​
name = 'ALEX'
new_name = name.lower()
print(new_name)
​

• split()【分割，可以加参数】

split  非常重要 比如(",",1)根据第几个逗号分割
默认按照空格分隔，返回一个列表
指定分隔符
str ---> list
s6 = '太白 女神 吴超'
s6 = '太白:女神:吴超'
l = s6.split(':')
print(l) 
​

• join()【通过什么连接的元素必须是字符串，形成的是字符串】

s1 = 'alex'
s2 = '+'.join(s1)
print(s2,type(s2))
​
l1 = ['太白', '女神', '吴超']
# 前提：列表里面的元素必须都是str类型
s3 = ':'.join(l1)
print(s3)
​

 

• format【字符串格式化】

# format: 格式化输出
# # 第一种用法：
# msg = '我叫{}今年{}性别{}'.format('大壮',25,'男')
​
# 第二种用法：
msg = '我叫{0}今年{1}性别{2}我依然叫{0}'.format('大壮', 25,'男')
print(msg)
​
# 第三种用法：
a = 100
msg = '我叫{name}今年{age}性别{sex}'.format(age=a,sex='男',name='大壮')
print(msg)
​
v1 = '我是{0}，年龄{1}'.format(*('alex',19,)) *args(位置参数) 
v1 = '我是{name}，年龄{age}'.format(**{'name' = 'alex','age' = 19}) **kwarg(关键字参数)
​

• startswith()[以什么开头]/endswith[以什么结尾]

# startswith endswith
# print(s.startswith('t'))  ***
# print(s.startswith('taiBAi'))  ***
# 了解
# print(s.startswith('B',3,6))
​

• is系列

# is 系列：
name = 'taibai123'
name = '100①'
print(name.isalnum()) #字符串由字母或数字组成
​
print(name.isalpha()) #字符串只由字母组成
​
print(name.isdecimal()) #字符串只由十进制组成
​
​

• center()【居中】

s1 = 'barry'
print(s1.center(20))
print(s1.center(20,'*'))
​

• capitalize()【首字母大写，其余变小写】

s1 = 'taiBAi'
print(s1.capitalize())
​

• swapcase()【大小写反转】

s1 = 'taiBAi'
print(s1.swapcase())
​

• title()【每个单词的首字母大写】

msg= 'taibai say hi'
print(msg.title())
​

 

3.3 共公方法

• count()【计数】

# count
# s8 = 'sdfsdagsfdagfdhgfhgfhfghfdagsaa'
# print(s8.count('a'))
​

• find ():通过元素找索引，找到第一个就返回，找不到 返回 -1【str独有】

  s1 = 'barry'
  print(s1.find('a'))
  print(s1.find('r'))
  print(s1.find('o'))
  ​

• index()【通过元素找索引，找到第一个就返回，找不到就 报错】

s1 = 'barry'
print(s1.index('o')
​

• len():计算长度

• 索引【0作为开始】

v = "oldboy"
v1 = v[0] #0 1 2 3 ...从前向后
v2 = v[-1] #-1 -2 -3...从前向后
​
​

• 切片【0作为开始】

v = "oldboy"
•# v1 = v[2:4] #   2 =< 索引位置 <3
# v2 = v[3:6]
# v2 = v[3:-1]
# v2 = v[3:]
# v2 = v[:-1]
# print(v2)•
​
# 示例: 取最后两个字符
# data = input('请输入：')
# 方式一
# v = data[-2:]
# print(v)
​
# 方式二
# total_len = len(data)
# v = data[total_len-2:total_len]
# print(v)
​

• 练习题

"""
需求：让用户输入任意字符串，获取字符串之后并计算其中有多少个数字。
"""
total = 0
user = input('请输入内容:')
index = 0
num = len(user)#计算长度
while True:
    val = user[index]#索引取值
    flag = isdecimal(val)#判断是否是数字
    if flag：
        total += 1
    if index == num - 1
        break
    index += 1
print(total)
​
​
​
# num = 0
# total = 0
# text = input('请输入内容：')
# while num < len(text):
#     flag = text[num].isdecimal()
#     if flag:
#         total += 1
#     num += 1
# print(total)
​

• for 可以被for循环

name = 'alex'
for item in name:
    print(item)
​

• 步长

name = 'alex'
​
# val = name[0:-1:2]
# val = name[1:-1:2]
# val = name[1::2]
# val = name[::2]
# val = name[-1:0:-2]
# print(val)
# 笔试题：请将字符串反转。
val = name[::-1]
print(val)
​

 

 

4 int 和str，bool之间的转换【重点】

# int ---> bool
i = 100
print(bool(i))  # True  # 非零即True
i1 = 0
print(bool(i1))  # False 零即False
​
# bool ---> int
t = True
print(int(t))  # 1  True --> 1
t = False
print(int(t))  # 0  False --> 0
​
# int ---> str
i1 = 100
print(str(i1))  # '100'
​
# str ---> int  # 全部由数字组成的字符串才可以转化成数字
s1 = '90'
print(int(s1))  # 90
​
# str ---> bool
s1 = '太白'
s2 = ''
print(bool(s1))  # True 非空即True
print(bool(s2))  # False
# bool ---> str
t1 = True
print(str(True))  # 'True'
​

5 列表（list）

5.1列表初识

• 定义：l1 = [100, 'alex',True,[1, 2, 3]] 可以承载任意数据类型，存储大量数据。以后想要表示多个事务可以用列表，而且是可变的数据类型。

• python常用的容器型数据类型，list列表。其他语言：Java，数组。

• 列表可以相加，还可以和数字相乘。

• 列表是有序的，可以索引，切片（步长）。

5.2 公共方法

• len()

users = ["李邵奇","奇航",99]
val = len(users)
print(val) # 3
​

• 索引

users = ["李邵奇","奇航",99]
val = users[0]
print(val)# "李邵奇"
​

• 切片

users = ["李邵奇","奇航",99]
​
val = users[0:2]# ["李邵奇","奇航"]
​

• 删除（int/bool/str)

users = ["李邵奇","奇航",99]
# 方式一
users.pop(1) # 可以索引删除，默认删除最后一个元素
print(users)
​
# 方式二：
del users[1] # 可以切片，索引，步长进行删除
print(users)
​

• 修改（int\str\bool除外）

users = ["李邵奇","奇航",99]
users[2] = 66
​
users[0] = '李杰'
users[0][1]
​
​
# l1 = [1, 2, 'taibai', [1, 'alex', 3,]]
# # 1, 将l1中的'taibai'变成大写并放回原处。
# l1[2] = 'TAIBAI'# l1[2] = l1[2].upper
​

• 步长

users = ["李邵奇","奇航",99]
​
val = users[0:2:2]
users[::-1] # 反转
​

• 练习题

"""
实现一个整数加法计算器(两个数相加)：
​
如：content = input("请输入内容:") 用户输入：5+9或5+ 9或5 + 9（含空白），然后进行分割转换最终进行整数的计算得到结果。
"""
示列一【支持多个输相加】
count = 0
content = input('请输入内用：')
new_content = content.split('+')
for i in new_content:
    count += i
print(count)
​
​
示例二【只支持两个数相加】
content = input('请输入内容：')
result = content.split('+')
val = int(result[0]) + int(result[1])
print(val)
​
​

• for 循环

users = ['李邵奇','利奇航','张三丰','李子森']
for i in users:
    print(i)
    
​
users = ['李邵奇','利奇航','张三丰','李子森']
for i in range(len(users))
    print(i)
​

• 索引为奇数对应的元素删除（不能一个一个删除，此l1只是举个例子，里面的元素不定）。

# 循环一个列表的时，最好不要改变列表的大小，这样会影响你的最终的结果。
​
方法一：【步长】
l1 = [11, 22, 33, 44, 55]
del l1[1::-2]
print(l1)
​
方式二：【倒序删除】
l1 = [11, 22, 33, 44, 55]
for i in range(len(l1) - 1, -1, -1):
    if i % 2 == 1:
        l1.pop(i) # del l1[i]
print(l1)
​
方式三：【思维置换】
l1 = [11, 22, 33, 44, 55]
new_l1 = []
for i in range(len(l1)):
    if i % 2 == 0:
        new_l1.append(l1[i])
l1 = new_l1
print(l1)
​

 

5.3 独有方法【常用】

• append()【追加】

users = []
users.append('alex')
print(users)
['alex']
​
示例一
users = []
while 1:
    name = input('请输入姓名：')
    users.append(name)  #添加到列表
    print(users)
​
    
示例二
# 录入用户密码
users = []
for i in range(0,3):
    name = input('请输入姓名和密码：')
    users.append(name)
print(users)#['alex,123', 'oldboy,888', 'lishaoqi,123']
​
​
# 用户和密码校验
username = input('请输入要登陆用户名：')
password = input('请输入要登陆密码：')
for item in users:
    result = item.split(',') # ['alex','123']
    user = result[0]
    pwd = result[1]
    if user == username and pwd == password:
        print('登陆成功')
        break
​

• insert()【插入，可以通过索引位置插入】

users = ['李邵奇','利奇航','张三丰','李子森']
users.insert(1,'小黑')
print(users)
​

• remove()【删除/删除指定元素，如果有重名元素从左至右第一个】

users = ['李邵奇', '张三丰', '利奇航', '张三丰', '李子森']
users.remove('张三丰')
print(users)
​

• pop()【删除，默认删除最后一个】（有返回值）

users = ['李邵奇', '张三丰', '利奇航', '张三丰', '李子森']
users.remove('张三丰')
print(users)
​

• clear()【清空】

users = ['李邵奇','张三丰','利奇航','张三丰','李子森']
users.clear()
print(users)
[]
​

• extend()【迭代追加】【可迭代是可以被for循环的】

users = ['李邵奇','张三丰','利奇航','张三丰','李子森']
name = "alex"
users.extend(name)
print(users)
['李邵奇', '张三丰', '利奇航', '张三丰', '李子森', 'a', 'l', 'e', 'x']
​

• reverse()【反转】

users = [12,15,33,14,13]
users.reverse()
print(users)
[13, 14, 33, 15, 12]
​

• sort()【排序】

users = [12,15,33,14,13]
users.sort(reverse = False)#从小到大（默认）
users.sort(reverse= True）#从大到小
print（v1)
​

5.4 列表嵌套【重点】

users = ["alex",0,True,[11,22,33,"老男孩"],[1,['alex','oldboy'],2,3]]
​
users[0]
users[2]
users[0][2]
users[3] # [11,22,33,"老男孩"]
users[3][-1] # "老男孩"
users[3][-1][1] # '男'
users[3] = 666
​

• 增 ：append()追加，insert()插入，extend()迭代添加

• 删

  • pop 按照索引删除。有返回值，默认删除最后一个

  • remove 按照元素删除

  • clear 清空

  • del 索引，切片（步长）

• 改：索引，切片，步长

• 查：索引，切片，for

6 元组（tuple)【独有方法无】

6.1 书写规范

users = [11,22,33,"老男孩"] # 列表（可变）
​
users = (11,22,33,"老男孩") # 元组（不可变）
​

6.2 公共方法

• 索引【排除：int/bool】

users = (11,22,33,"老男孩")
​
print(users[0])
print(users[-1])
​

• 切片【排除：int/bool】

users = (11,22,33,'老男孩')
print(users[0:2])
​

• 步长【排除：int/bool】

users = (11,22,33,"老男孩")
print(users[0:2:2])
​

• 删除【排除：tuple/str/int/bool】

• 修改【排除：tuple/str/int/bool】

• for 循环【排除：int/bool】

users = (11,22,33,"老男孩")
for item in users:
    print(item)
​

• len()【排除：int/bool】

users = (11,22,33,"老男孩")
print(len(users))
​

• count()【计数】

tu = (1,2,3,3,3,2,2,3,)
print(tu.count(3))
​

• index()【通过元素找索引，找到第一个就返回，找不到 报错】

tu = ('太白', '日天', '太白')
print(tu.index('太白')
​

 

6.3 拆包

• 元组的拆包允许你将可迭代中（大多是元组）的每个项分配给变量

a,b = (1,2)
print(a,b)
​

• 以 星号(*)作为前缀的变量接受其他变量遗留的所有可迭代的值。

a,b,*c,d = [1,2,3,4,5,6,7,8,9,10]
print(a,b,c,d)
​

 

6.4 特殊： 元组的元素不可修改和删除【元组的嵌套】

如果元组内部元素是可变类型，则这个元素内部就可以被修改。

# 示例一：
v1 = (11,22,33)
v1[1] = 999 # 错误
v1 = 999  # 正确
​
# 示例二：可以嵌套
v1 = (11,22,33,(44,55,66),(11,2,(99,88,),3))
​
# 示例三：嵌套
v2 = [11,22,33,(11,22,33)]
v2[-1][1] = 99 # 错误
v2[-1] = 123 # 正确
​
# 示例四：嵌套
v3 = (11,[1,2,3],22,33)
v3[1] = 666 # 错误
v3[1][2] = 123
​

• 元组中如果只有一个元素，并且没有逗号，那么它不是元组，它与该数据类型一至。

tu1 = (1,) #是元组
tu1 = (1) # int类，它与该数据类型一至
​

 

6.4 元组和列表的转换【常见的类型转换】

• 字符串【str】转【list】

v1 = list("asdfadfasfdadfasfd")
print(v1)
​

• 元组【tuple】转【list】

v = (11,22,33,44,) 
v1 = list(v)
print(v1)
​

• 字符串【str】转元组【tuple】

v = 'adfadfasdfasdfasdfafd'
v1 = tuple(v)
print(v1)
​

• 列表【list】转元组【tuple】

v = [11,22,33,44]
v1 = tuple(v)
print(v1)
​

• 注：集合跟列表之间也可进行转换。

  列表的去重
  alist =['a','b','c','c','b','e','a','f']
  print(list(set(alist))) # 不会按照原来的索引位置排列，是由集合无序的特性决定的
  ​

• 注：常见的类型转换【强制转换】

# 字符串转数字 只能是数字组成的字符串
​
# 数字转字符串
​
# 列表转元组
​
# 元组转列表
​
# 其他转bool时，只有：0 ,“”,[] ,() ,{},set()是False ，其他都是True【非空即True】
​

 

7 字典【dict】

7.1 帮助用户取表示事务信息（事务是有多个属性）

• 容器型数据类型：dict

• 数据之间的关联性强，查询速度快

• 缺点：以空间换时间

• 数据类型分类：

  • 可变（不可哈西）的数据类型:list,dict,set

  • 不可变（可哈希）的数据类型:str,bool,int,tuple

• 字典3.5x版本之前（包括3.5）是无序的。

• 字典3.6x会按照初次建立字典的顺序排列，学术上不认为是有序的。

• 字典3.7x以后都是有序的。

• 格式:{}括起来，以键值对形式存储的容器型数据类型

data = {键:值,键:值,键:值,键:值,键:值,键:值,}
​

• 键必须是不可边的数据类型：int，str （bool，tuple几乎不用）唯一的。

• 值可以是任意数据类型，对象。

• 字典的创建

# 面试会考
# 方式一：
# dic = dict(('one', 1), ('two', 2), ('three', 3))
# print(dic)  # {'one': 1, 'two': 2, 'three': 3}
​
# 方式二：
# dic = dict(one=1, two=2, three=3)
# print(dic)
​
# 方式三：
# dic = dict({'one': 1, 'two': 2, 'three': 3})
# print(dic)
​
​
# dict 创建字典的几种方式
# 直接创建
# 元组的解构
# dic = dict([(1,'one'),(2,'two'),(3,'three')])
# dic = dict(one=1,two=2)
# print(dic)
# fromkeys
# update 依赖于字典
# 字典的推导式
​

• 验证合法性

dic = {[1,2,3]:'alex',1:666} # 键要是不可变的数据类型
print(dic)
# 键要是唯一的,不可重复
​

7.2 独有功能【常用】

info = {"name":'刘伟达','age':18,'gender':'男','hobby':'同桌'}
​

• keys，获取字典中所有的键。

for key in info.keys:
    print(key)
​
for key in info:
    print(key)
​
这两种等价
​

• values,获取字典中所有的值

for value in info.values:
    print(value)
​

• items,获取字典中的所有键值对。

for v1,v2 in info.items:
    print(v1,v2)
​

• get* 【查询键在不在字典中，可以加参数】

info ={'k1':'v1','k2':'v2'}
info.get('k111111',666)#  可以设置返回值
print(info) #结果666
​
info.get('k111111')
print(info)#结果None：就是python中的空。
#None数据类型，改类型表示空（没有任何功能，专门表示空）
​

• pop（根据键索引删除，有返回值）和 del

info = {'k1':'v1','k2':'v2'}
result = info.pop('k2')
print(info,result)#保留值
​
del info['k1']#不保留值，没有返回值
​

• update（更新）【存在，则更新/不存在则添加】

info = {'k1':'v1','k2':'v2'}
dic = {'k3':'v3','k4':'v4','k2':666}
info.update(dic)
print(info)
​
info.update(k3='v3',k4='v4',k2=666)
print(info)
​
​
info.update([(1, 'a'),(2, 'b'),(3, 'c'),(4, 'd')])
print(info) # 面试会考
​

• setdefault 【有则不变，无则增加】

info = {'k1':'v1','k2':'v2'}
info.setdefault('k1',2)
print(info)
​
info = {'k1':'v1','k2':'v2'}
info.setdefault('k3',2)
print(info)
​

• fromkeys()

dic = dict.fromkeys('abc', 100)
print(dic)
​
dic = dict.fromkeys([1, 2, 3], 'alex')
print(dic)
​

• 坑

# 值共有几个，面试题
dic = dict.fromkeys([1,2,3],[])
dic[1].append(666)
print(dic) # {1:[666],2:[666],3:[666]}
​

• 循环一个字典时，如果改变这个字典的大小，就会报错。

# 将字典中键含有'k'元素的键值对删除。
dic = {'k1': '太白', 'k2': 'barry', 'k3': '白白', 'age': 18}
​
for i in list(dic): #正确做法，dic等同dic.keys
    if 'k' in i:
        del dic[i]
print(dic)
​
​
for i in list(dic):
    if 'k' in i:
        dic.pop(i)
print(dic)
​

 

7.3 公共功能

• len

info = {"name":'刘伟达','age':18,'gender':'男','hobby':'同桌'}
print(len(info))
​

• 根据键取值

info = {"name":'刘伟达','age':18,'gender':'男','hobby':'同桌'}
info['name']
info['age']
​
print(info['name'],info['age'])
​

• 切片【无】

• 步长【无】

• for循环

info = {"name":'刘伟达','age':18,'gender':'男','hobby':'同桌'}
​
取键：
for item in info.keys():
    print(item)
取值：
for item in info.values():
    print(item)
取键和值：
for k,v in info.items():
    print(k,v)
​

• 修改【存在则修改/不存在就增加】

# 改值
​
info = {"name":'刘伟达','age':18,'gender':'男','hobby':'同桌'}
info['age'] = 19 # 通过键修改
print(info)
​
# 改建：删除后再增加
del info['hobby']
info['xxxxx'] = 'x1'
​

• 增

  • 有则修改，无则增加【info['键'] = '新值'】

  • update():有则更新，无则增加

  • setdefault()：有则不变，无则增加

• 删

  • pop：按照键删除键值对，有返回值（设置第二参数则无论有无此键都不会报错 info.pop('hobby','没有此键') ）

  • del

  • clear：清空

• 改：info['键'] = '新值'

• 查

  • get***：可以设置返回值和第二参数（不会报错）

  • 索引

7.4 字典的嵌套

dic = {
    'name': '汪峰',
    'age': 48,
    'wife': [{'name': '国际章', 'age': 38},],
    'children': {'girl_first': '小苹果','girl_second': '小怡','girl_three': '顶顶'}
}
​
# 1. 获取汪峰的名字。
print(dic['name'])
​
# 2.获取这个字典：{'name':'国际章','age':38}。
print(dic['wife'][0])
​
# 3. 获取汪峰妻子的名字。
print(dic['wife'][0]['name'])
​
# 4. 获取汪峰的第三个孩子名字。
print(dic['children']['girl_three'])
​

7.5 字典转列表

dic = {'k1':'太白','k2':'barry','k3': '白白', 'age': 18}
# 
print(list(dic)) # 列表获取所有键
print(list(dic.values())) # 列表获取所有值
​

7.6 字典推导式

字典推动式通过{key:value+表达式}的方式生成一个字典

{i:str(i) for i in range(1, 5)} {1: '1', 2: '2', 3: '3', 4: '4'} #由range对象i和i转化成的字符串组成的字典

x = ['A', 'B', 'C', 'D'] y = ['a', 'b', 'b', 'd'] {i:j for i,j in zip(x,y)} #通过zip对象+两个字符型列表组成字典 {'A': 'a', 'B': 'b', 'C': 'b', 'D': 'd'}

7.7 有序字典

from collections import OrderedDict
​
info = OrderedDict()
info['k1'] = 123
info['k2'] = 456
​
print(info.keys())
print(info.values())
print(info.items())
​

 

 

8 集合【set()】

8.1 python基础数据类型：集合set()

• 定义：容器类型的数据类型，它要求它里面的元素是不可变的，它自己又是可变的数据类型。

• 集合：是无序，无重复的

• 作用：列表去重和关系测试

• 空集合：set()

8.2 集合的创建

set1 = set({1,2,'barry',False})
print(set1)
​
ste1 = {1,3,'太白金星'，4，'alex'}
print(set1)
​

• None:空的表达示

int:v1 = int() --> 0
bool: v2 = bool()--> False
str: v3 = "" --> str()
list: v4 = [] --> list()
tuple: v5 = () --> tuple()
dict: v6 = {} --> dict()
set:v7 = set()【集合的空只能这么表示】
​

8.3 独有功能(关系测试)

• add()【添加】

v = {1,2}
v.add('lishaoqi')
print(v)
​

• update()【迭代追加】

v  = {1,2}
v.update({11,22,33})
print(v)
​

• discard()【删除】

v = {1,2,'lishaoqi'}
v.discard('lishaoqi')
print(v)
​

• remove()【按照元素删除】

v = v = {1,2,'lishaoqi'}
v.remove('lishaoqi')
print(v)
​

#变相改值
v = v = {4,2,'lishaoqi',3}
v.remove(2)
v.add('男神')
print(v)
​

• pop()【随机删除】[有返回值]

v = v = {1,2,'lishaoqi'}
v.pop
print(v)
​

• intersection()【交集】【重点】

v = {1,2,'李邵奇'}
result = v.intersection({1,'李邵奇','小黑'})
print(result)
​
set1 = {1, 2, 3, 4, 5}
set2 = {4, 5, 6, 7, 8}
print(set1 & set2)
​

• union()【并集】

v = {1,2,'李邵奇'}
result = v.union({1,'李邵奇','小黑'})
print(result)
​
​
​
set1 = {1, 2, 3, 4, 5}
set2 = {4, 5, 6, 7, 8}
print(set1 | set2)
​

• difference()【差集】

v = {1,2,'李邵奇'}
result = v.difference({1,'李邵奇','小黑'}) # v中有且{1,'李邵奇','小黑'}没有
print(result)
​
​
set1 = {1, 2, 3, 4, 5}
set2 = {4, 5, 6, 7, 8}
print(set1 - set2)# 1 2 3
print(set2 - set1)# 6 7 8
​

• symmetric_difference()【对称差集】

v = {1,2,'李邵奇'}
result = v.symmetric_difference({1,'李邵奇','小黑'})
print(result)
​
set1 = {1, 2, 3, 4, 5}
set2 = {4, 5, 6, 7, 8}
print(set1 ^ set2)
​

• 其他

# 反交集
# print(set1 ^ set2)
​
# 子集
# set1 = {1,2,3}
# set2 = {1,2,3,4,5,6}
# # print(set1 < set2)
#
# # 超集
# print(set2 > set1)
​
​

8.4 列表去重【重点】

l1 = [1,'太白', 1, 2, 2, '太白',2, 6, 6, 6, 3, '太白', 4, 5, ]
set1 = set(l1)
l1 = list(set1)
print(l1)
​
l1 = list(set(l1))
print(l1)
​