2. 数据类型

数据类型

1.字符串

  • 单引号,双引号,三引号
  • upper,lower 大小写转换
.upper() /.lower()
  • strip 去除字符串两边的 空格、换行符、制表符
value.strip()
value.lstrip()
value.rstrip()
  • split 字符串切割
#以xx切割字符,切割之后保持在列表中
aa|bb|cc|dd
value.rsplit('|',1) #['aa|bb|cc', 'dd']
value.split('|')    #['aa', 'bb', 'cc', 'dd']
value.split('|',1)  #['aa', 'bb|cc|dd'] 
  • replace 替换
.replace('要替换的值','替换之后的值')
.replace('要替换的值','替换之后的值',1) 
# 1  从左到右找找到第一个,替换
# 2  从左到右找找到前两个,替换
  • join 拼接
value = ["aa","cc"]
result = ' bb '.join(value)
print(result)
#aa bb cc
lists1 = (1,2,3)
lists2 = [1,2,3]
result1 = ",".join(list1)
result2 = ",".join(list2)
print(result1)
1,2,3
join可以对列表和元组进行字符串转换
  • format 格式化字符串
name = "{0} like work,Joking {1} {2}!"
date = name.format("Bing","of","course")
#print Bing like work,Joking of course!
  • isdigit 检测字符串是否只由数字组成,是返回True,否False
.isdigit()
  • startswith 字符串是否以 XX 开头,是返回True,否False
.startswith("xx")
  • endswith 字符串是否以 XX 结尾,是返回True,否False
.endswith("xx")
  • isdecimal 字符串是否为十进制数
.isdecimal()
  • encode 编码转换
v1 = name.encode('utf-8') 
print(v1) 
v2 = name.encode('gbk') 
print(v2)
  • 其他

1.获取字符串长度
  name = "bing"
  name_length = len(name)
  print(name_length) # 输出:3
  nickname = "wupeiqi"
  length = len(nickname)
  print(length) # 输出:7

2.索引,获取字符串中某个字符的值。
  name = "来做点交易"
  来做点交易
  0 1 2 3 4   正数  print(name[0],name[1],name[4])    #来 做 易
  5 4 3 2 1   负数  print(name[-1],name[-2],name[-3]) #易 交 点
  print( name[len(name)-1]) # 输出 易
  #案例:循环字符串的所有字符
  content = "长江以北晓峰最美山海关以外晓峰最帅"
  index = 0
  while index < len(content): char = content[index] print(char) index += 1 #案例:循环字符串的所有字符 content = "你瞅啥" index = -1 while index >= - len(content):
       char = content[index]
       print(char)
       index -= 1
  #练习题:获取用户输入的字符判断他的数字的字符串中有一个数字(只考虑个位数)?例如 你有点2,还特么有点666这段字符串中有4个数字。
  index = "你有点2,还特么有点666这段字符串中有4个数字。"
  index_len = len(index)
  a = 0
  tatal = 0
  while True:
      wal = index[a]
      #print(wal)
      flag = wal.isdigit()
      if flag:
          tatal = tatal + int(wal)
      if a == index_len -1:
          break
      a += 1
  print(tatal)

3.切片,获取字符串中n连续的字符的值。
  #注意:切片截取 不包含最后一个字符
  name="你是风儿我是沙。不,我不是沙而是你爸"
  你是风儿我是沙 。不, 我 不 是 沙 而 是 你 爸
  0 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17
  [0:2]  [2:5]
   你是   风儿我
  print( name[0:len(name)]) # 输出:你是风儿我是沙。不,我不是沙而是你爸

4.步长,相当于我们生活中的跳步选择数据。
  [::2]从第一个字符开始,取第二个
  name = "生活不是电影 ,生活比电影苦"
          1 1 2 1 2 1 2 1 2 1 2 1 2
  [ 2::3 ] 从第三个字符开始,去第三个
  name = "生活不是电影 ,生活比 电 影 苦"
          0 1 2 3 4 5 6 7 8 9 10 11 12
              1 1 2 3 1 2 3 1  2  3   
  [ 8:1:-1 ] 从第九个字符开始,倒序打出1,表示到前面的0 1 结束
  name = "生活不是电影 ,生活比 电 影 苦"
          0 1 2 3 4 5 6 7 8 
              1 1 1 1 1 1 8

5.for循环
  #想要循环显示字符串的每个字符,通过之前的 while循环 + 索引 可以实现,现在通过for循环则可以更方便的实现。
  content = "三分天注定,七分靠滤镜"
  for item in content:
     print(item)
  #案例:判断用输入的值中有多少个字符 `a`(不区分大小写,即:A、a)
  total_count = 0
  content = input("请输入内容:")
  for char in content:
     if char.upper() == 'A':
         total_count += 1
  message = "您输入的内容中A/a共有{}个".format(total_count)
  #案例:break和continue也可以应用在for循环中
  data = "像我这样优秀的人,本该灿烂过一生"
  for item in data:
     print(item)
     if item == "人":
         break

2.整数

#兼容python2.7,3.5版本不需要导入模块
from __future__ import division
#强制转换
int("字符串") 【重要】
int(布尔值)

3.布尔

转换为布尔值
数0、空字符串、空列表、空元祖、空字典转换为布尔值时均为False
其他均为True整
and,第一个值转换为布尔,如果是 `真` 则选择第二个值,第一个为假,则选第一个值。
or   第一个值转换为布尔,如果是 `真` 则选择第一个值,第一个为假,则选第二个值

#例:
v1 = 1 and 6 or 8 and 0 or ""
# 结果:v1 = 6
# 流程分析:
#   第一步:处理 1 and 6,得到 v1 = 6 or 8 and 0 or ""
#   第二步:处理 8 and 0,得到 v1 = 6 or 0 or ""
#   第三步:处理 6 or 0 ,得到 v1 = 6 or ""
#   第四步:处理 6 or "",得到 6

a = 6 or 2 > 1   # 6   
b = 3 or 2 > 1   # 3
c = 0 or 5 < 4   # False
d = 5 < 4 or 3 # 3 e = 2 > 1 or 6   # True
f = 3 and 2 > 1  # True
g = 0 and 3 > 1  # 0
h = 2 > 1 and 3  # 3
i = 3 > 1 and 0  # 0
j = 3 > 1 and 2 or 2 < 3 and 3 and 4 or 3 > 2  # 2

#查看一些变量为True还是False
#空的元组,列表,字典,字符串,和0都是False
#其他都是True
v1 = bool(0)
v2 = bool(-10)
v3 = bool(10)
v4 = bool("武沛齐")
v5 = bool("")
v6 = bool(" ")
v7 = bool([]) # [] 表示空列表
v8 = bool([11,22,33]) # [11,22,33] 表示非空列表
v9 = bool({}) # {} 表示空字典
v10 = bool({"name":"武沛齐","age":18}) # {"name":"武沛齐","age":18} 表示非空字典
v11 = bool(())  # ()空元组
#print(v1)
1 False
2 True
3 True
4 True
5 False
6 True
7 False
8 True
9 False
10 True
11 False

布尔优先级,优先级从高到低依次是:

  • 算数优先级 > 比较运算符(乘 除 加 减等)
  • 比较运算符 > 逻辑运算符(大于,不等于,小于等)
  • 逻辑运算符内部三个优先级 not > and > or

4.列表

 

  • append 追加

 

 

#在原列表中尾部追加值。
 data_list = []
 v1 = input("请输入姓名")
 v2 = input("请输入昵称")
 data_list.append(v1)
 data_list.append(v2)
 date_list[1].append(v2)
 print(data_list)

 

    • insert 插入

 

#在原列表的指定索引位置插入值 
 user_list = ["苍老师","有坂深雪","大桥未久"]
 user_list.insert(0,"马蓉")    #在0索引插入
 user_list.insert(2,"李小璐")  #在2索引插入
 print(user_list)

 

    • extend 合并列表

 

#将一个列表中的元素添加另外一个列表。 
 tools = ["搬砖","菜刀","榔头"]
 weapon = ["AK47","M6"]
 # weapon中的值逐一追加到tools中
 tools.extend(weapon) 
 print(tools)

 

    • remove 根据值删除(从左到右找到第一个删除)

 

user_list = ["王宝强","陈羽凡","Alex","贾乃亮","Alex"]
 user_list.remove("Alex")
 print(user_list)

 

    • pop 根据索引删除某个元素

 

 user_list = ["王宝强","陈羽凡","Alex","贾乃亮","Alex"]
 ele = user_list.pop()   # 在user_list删除最后一个,并讲删除值赋值给ele
 item = user_list.pop(2) # 在user_list中删除索引未2的值,并将删除值赋值给item

 

    • clear 清空列表

 

 user_list = ["王宝强","陈羽凡","Alex","贾乃亮","Alex"]
 user_list.clear()
 print(user_list)

 

    • reverse 反转原列表

 

user_list = ["王宝强","陈羽凡","Alex","贾乃亮","Alex"]
 user_list.reverse()
 print(user_list)

 

    • sort 排序

 

value.sort(reverse=False) #从小到大
value.sort(reverse=True) #从大大小

 

    • list 转换为列表

 

#如果想要让某些元素转换为列表类型,一般需要通过list强转,他的内部其实就是循环每个元素,再将元素追加到列表中。
所以,想要转换为列表类型有要求:必须可以被循环的元素才能转换为列表。
message = "我猜你的枪里没有子弹"
data = list(message)
print(data) # ["我","猜","你","的","枪","里","没","有","子","弹"]

 

    • 嵌套

 

#列表属于容器,内部可以存放各种数据,所以他也支持列表的嵌套,如:
data = [ "谢广坤",["海燕","赵本山"],True,[11,22,33,44],"宋小宝" ]
#对于嵌套的值,可以根据之前学习的索引知识点来进行学习,例如:
data = [ "谢广坤",["海燕","赵本山"],True,[11,22,33,44],"宋小宝" ]
print( data[0] )
print( data[1] )
print( data[0][2] )  #0中的第三个字符
print( data[1][-1] ) #1中的最后一个字符
data.append(666)
print(data)
del data[-2]
print(data)
data[1].append("谢大脚")
print(data)

 

    • 其他

 

        #获取长度
user_list = ["范德彪","刘华强",'尼古拉斯赵四']
print( len(user_list) )

        #索引
user_list = ["范德彪","刘华强",'尼古拉斯赵四']
print( user_list[0] )
print( user_list[2] )
print( user_list[3] )

        #根据索引删除元素
user_list = ["范德彪","刘华强",'尼古拉斯赵四',"宋小宝","刘能"]
del user_list[1]
del user_list[3]

        #根据索引替换元素
user_list = ["范德彪","刘华强",'尼古拉斯赵四',"宋小宝","刘能"]
user[0] = "王大拿"
user[-1] = "广坤"

        #切片
user_list = ["范德彪","刘华强",'尼古拉斯赵四']
print( user_list[0:2] )
print( user_list[1:] )
print( user_list[:-1] )

        #步长
user_list = ["范德彪","刘华强",'尼古拉斯赵四',"宋小宝","刘能"]
print( user_list[1:4:2] )
print( user_list[0::2] )
print( user_list[1::2] )
print( user_list[4:1:-1] )
        
        #for循环
user_list = ["范德彪","刘华强",'尼古拉斯赵四',"宋小宝","刘能"]
for item in user_list:
 print(item)
user_list = ["范德彪","刘华强",'尼古拉斯赵四',"宋小宝","刘能"]
for item in user_list:
 if item == '刘华强':
     continue
 print(name)

5.元组

#元组也是一个容器,里面可以存放各种数据(和列表相似)
但他有一个特殊的特点:元组的儿子元素不允许添加、不允许修改、不允许删除,只能读。
v1 = (1,2,3)       # v1[0]=3不可以修改
v1 = ([1,2],2,3)   # v1[0][0]=2 可以修改
v1 = [1,2,(1,2,3)] # v1[2][0]=1 不可以修改 v1[2]=3 可以整体替换
一般用于存储一些在程序中不应该被修改的一系列值。

元组的定义
v1 = (11,22,33,)
v2 = ("武沛齐","Alex",)
v3 = ("武沛齐",)
注意:建议在元组的最后多加一个逗号,用于标识他是一个元组。

# 面试题
1. 比较值 v1 = (1) 和 v2 = 1 和 v3 = (1,) 有什么区别?
type v1 <class 'int'>
type v2 <class 'int'>
type v3 <class 'tuple'>

2. 比较值 v1 = ((1),(2),(3)) 和 v2 = ((1,),(2,),(3,),) 有什么区别?
v1 = [(1),(2),(3)] 等价于 [1,2,3]  
v2 = ((1,),(2,),(3,),) 是元组

	
转换
其他类型可以转换为元组,一般可以被循环的元素才能转换,目前我们学到的可以被循环有:字符串和列表。
name = "武沛齐"
data = tuple(name)
print(data) # 输出 ("武","沛","齐")
name = ["武沛齐",18,"pythonav"]
data = tuple(name)
print(data) # 输出 ("武沛齐",18,"pythonav")

其他

元组和列表非常相似,但由于元组的子元素无法修改的特点,所有在元组都没有修改、删除、添加的操作,只有读操作。

	#获取长度
user_list = ("范德彪","刘华强",'尼古拉斯赵四',)
print( len(user_list) )

	#索引
user_list = ("范德彪","刘华强",'尼古拉斯赵四',)
print( user_list[0] )
print( user_list[2] )
print( user_list[3] )

	#切片
user_list = ("范德彪","刘华强",'尼古拉斯赵四',)
print( user_list[0:2] )
print( user_list[1:] )
print( user_list[:-1] )

	#步长
user_list = ("范德彪","刘华强",'尼古拉斯赵四',"宋小宝","刘能")
print( user_list[1:4:2] )
print( user_list[0::2] )
print( user_list[1::2] )
print( user_list[4:1:-1] )

	#for循环
 user_list = ["范德彪","刘华强",'尼古拉斯赵四',"宋小宝","刘能"]
 for item in user_list:
     print(item)
 user_list = ["范德彪","刘华强",'尼古拉斯赵四',"宋小宝","刘能"]
 for item in user_list:
  if item == '刘华强':
      continue
  print(name)

	#嵌套
由于元组和列表都可以充当容器,他们内部可以放很多元素,并且也支持元素内的各种嵌套。

tu = ('今天姐姐不在家','姐夫和小姨子在客厅聊天',('姐夫问小姨子税后多少钱','小姨子低声说道说和姐夫还提钱'))
tu1 = tu[0]
tu2 = tu[1]
tu3 = tu[2][0]
tu4 = tu[2][1]
print(tu1) # 今天姐姐不在家
print(tu2) # 姐夫和小姨子在客厅聊天
print(tu3) # 姐夫问小姨子税后多少钱
print(tu4) # 小姨子低声说道说和姐夫还提钱
# 练习题:判断是否可以实现,如果可以请写代码实现。
li = ["alex",[11,22,(88,99,100,),33] "WuSir", ("ritian", "barry",), "wenzhou"]
- 请将 "WuSir" 修改成 "武沛齐"
- 请将 ("ritian", "barry",) 修改为 ['日天','日地']
- 请将 88 修改为 87
- 请将 "wenzhou" 删除,然后再在列表第0个索引位置插入 "周周"

6.字典

字典也可以当做是个容器,在内部可以存放数据。相比较于元组和列表,字典的元素必须是 键值对。

注意:在Python3.6+字典就是有序了,之前的字典都是无需。

6.1 字典定义

info = {"age":12, "status":True, "name":"wupeiqi","hobby":['篮球','足球']}
# 例如: "age":12 称为一个键值对。
department_dict = {
    "IT部门":["武沛齐","Alex"],
    "销售部":["张三","刘能","张扬"],
    "财务部":["歪歪"]
}
department_dict = {
    "武沛齐":{"id":1,"gender":"男","email":"xx@live.com"},
    "Alex":{"id":1,"gender":"男","email":"xx@live.com"},
    "郭达":{"id":1,"gender":"男","email":"xx@live.com"},
    "刘能":{"id":1,"gender":"男","email":"xx@live.com"},
    "赵四":{"id":1,"gender":"男","email":"xx@live.com"},
    "广坤":{"id":1,"gender":"男","email":"xx@live.com"},
    ...
}
注意:字典的键有特殊要求,即:必须可哈希 。 目前为止学到的可哈希的类型:int/bool/str/tuple;不可哈希的类型:list/dict

合法
dic = {123: 456, True: 999, "id": 1, "name": 'sylar', "age": 18, "stu": ['帅
哥', '美⼥'], (1, 2, 3): '麻花藤'}
print(dic[123])
print(dic[True])
print(dic['id'])
print(dic['stu'])
print(dic[(1, 2, 3)])

不合法
# dic = {[1, 2, 3]: '周杰伦'} # list是不可哈希的. 不能作为key
# dic = {{1: 2}: "哈哈哈"}    # dict是不可哈希的. 不能作为key
# dic = {{1, 2, 3}: '呵呵呵'} # set是不可哈希的, 不能作为key

6.2 常见方法

 

  • keys 所有的键

 

 

info = {"age":12, "status":True, "name":"wupeiqi","email":"xx@live.com"}
data = info.keys() # 获取字典的所有的键,返回一个`高仿的`列表,存放的都是字典中的key。
print(data) # 输出:dict_keys(['age', 'status', 'name', 'email'])
info = {"age":12, "status":True, "name":"wupeiqi","email":"xx@live.com"}
for ele in info.keys():
 print(ele)
注意:在Python2中 字典.keys()直接获取到的是列表,而Python3中返回的是高仿列表,这个高仿的列表可以被循环显示。

 

    • values 所有的值

 

info = {"age":12, "status":True, "name":"wupeiqi","email":"xx@live.com"}
data = info.values()
print(data) # 输出:dict_values([12, True, 'wupeiqi', 'xx@live.com'])
info = {"age":12, "status":True, "name":"wupeiqi","email":"xx@live.com"}
for val in info.values():
 print(val) # 输出:dict_values([12, True, 'wupeiqi', 'xx@live.com'])
注意:在Python2中 字典.values()直接获取到的是列表,而Python3中返回的是高仿列表,这个高仿的列表可以被循环显示。

 

    • items 所有的键值

 

info = {"age":12, "status":True, "name":"wupeiqi","email":"xx@live.com"}
data = info.items()
print(data) # 输出 dict_items([('age', 12), ('status', True), ('name', 'wupeiqi'), ('email', 'xx@live.com')])
for item in info.items():
 print(item) # item是一个元组 (键,值)
for key,value in info.items():
 print(key,value) # key代表键,value代表值,将兼职从元组中直接拆分出来了。

 

    • update 更新字典键值对

 

info = {"age":12, "status":True}
info.update({"age":14,"name":"武沛齐"}) # info中没有的键直接添加;有的键则更新值
print(info) # 输出:{"age":14, "status":True,"name":"武沛齐"}

 

    • pop 移除字典的键值对

 

info = {"age":12, "status":True,"name":"武沛齐"}
data = info.pop("age")
print(info) # {"age":12,"name":"武沛齐"}
print(data) # 12

 

    • get 根据键获取值

 

info = {"age":12, "status":True,"name":"武沛齐"}
data = info.get("name",None) # 根据name为键去info字典中获取对应的值,如果不存在则返回None,存在则返回值。
print(data) # 输出:武沛齐

6.3 转换

由于字典的每一个元素是键值对,所以想要转换为字典的必须要有个特定的格式才能转换成功
v = dict([("k1","v1"),("k2","v2")])
print(v) # 输出:{'k2': 'v2', 'k1': 'v1'}
v = dict([ ["k1","v1"], ["k2","v2"] ])
print(v) # 输出:{'k2': 'v2', 'k1': 'v1'}
子元素必须包含两个元素,从而将值对应给字典的键、值。

6.4 其他

#取长度
  info = {"age":12, "status":True,"name":"武沛齐"}
  data = len(info)
  print(data) # 输出:3

#索引(键)
  字典不同于元组和列表,字典的索引是键,而列表和元组则是 0、1、2等数值 。

  info = {"age":12, "status":True,"name":"武沛齐"}
  print(info["age"])      # 输出:12
  print(info["name"])        # 输出:武沛齐
  print(info["status"])    # 输出:True
  print(info["xxxx"])       # 报错,通过键为索引去获取之后时,键不存在会报错(以后项目开发时建议使用get方法根据键去获取值)
  提示:字典根据键的查找速度非常快,远远大于列表或元组通过索引查找的速度,因为字典内部是基于hash存储。
  根据键 修改值 和 添加值 和 删除键值对
  上述示例通过键可以找到字典中的值,通过键也可以对字典进行添加和更新操作

  info = {"age":12, "status":True,"name":"武沛齐"}
  info["gender"] = "男" # gender键在字典中不存在,则自动在字典中新添加一个键值对
  print(info) # 输出: {"age":12, "status":True,"name":"武沛齐","gender":"男"}
  info = {"age":12, "status":True,"name":"武沛齐"}
  info["age"] = "18" # age键在info字典中已存在,则更新键对应的值
  print(info) # 输出: {"age":18, "status":True,"name":"武沛齐"}
  info = {"age":12, "status":True,"name":"武沛齐"}
  del info["age"] # 删除info字典中键为age的那个键值对(键不存在则报错)
  print(info) # 输出: {"status":True,"name":"武沛齐"}

#修改(存在修改/不存在增加)
info["age"] = 19

#删除
del info['name']

#for循环
 由于字典也属于是容器,内部可以包含多个键值对,可以通过循环对其中的:键、值、键值进行循环;
 info = {"age":12, "status":True,"name":"武沛齐"}
 for item in info.key():
     print(item)
 info = {"age":12, "status":True,"name":"武沛齐"}
 for item in info.values():
     print(item)
 info = {"age":12, "status":True,"name":"武沛齐"}
 for key,value in info.items():
     print(key,value)

#字典嵌套
  截止目前位置我们已学了:int/str/list/tuple/dict 五种常见数据类型,而其中list/tuple/dict类型中可以包含子元素,所以他们的内容就可以进行数据的嵌套。但在嵌套和对内部数据操作时要注意:元组子元素不能变、不可哈希的list、dict不能做字典的键。
 dic = {
     'name':'汪峰',
     'age':48,
     'wife':[{'name':'国际章','age':38}],
     'children':['第一个熊孩子','第二个熊孩子']
 }
 """
 1. 获取汪峰的妻子名字
     d1 = dic['wife'][0]['name']
     print(d1)
 2. 获取汪峰的孩子们
     d2 = dic['children']
     print(d2)
 3. 获取汪峰的第一个孩子
     d3 = dic['children'][0]
     print(d3)
 4. 汪峰的媳妇姓名变更为 章子怡
     dic['wife'][0]['name] = "章子怡"
     print(dic)
 5. 汪峰再娶一任妻子
     dic['wife'].append({"name":"铁锤","age":19})
     print(dic)
 6. 给汪峰添加一个爱好:吹牛逼
     dic['hobby'] = "吹牛逼"
     print(dic)
 7. 删除汪峰的年龄
     del dic['age']
     或
     dic.pop('age')_
     print(dic)
 """

7.集合

集合与元组和列表相似都用于做容器,在内部可以放一些子元素,但集合有三特殊特点: 子元素不重复 、 子元素必须可哈希、无序.

提示:目前可哈希的数据类型 int/str/tuple;不可哈希的类型tuple/list/set

7.1 集合的定义

v1 = {1,2,99,18}
v2 = {"武沛齐","Alex","老妖","Egon"}
v3 = {1,True,"world",(11,22,33)}
集合与字典虽然都是用{}括号,但字典内部是键值对,而集合内部直接是值。

7.2 常用方法

 

  • add 添加元素

 

 

data = {"刘嘉玲", '关之琳', "王祖贤"}
 data.add("郑裕玲")
 print(data)
 data = set()
 data.add("周杰伦")
 data.add("林俊杰")
 print(data)

 

    • discard 删除元素

 

 data = {"刘嘉玲", '关之琳', "王祖贤","张曼⽟", "李若彤"}
 data.discard("关之琳") 
 print(data)

 

    • update 批量添加

 

 update() 方法通过添加另一个集合中的项目来更新当前集合。
 如果两个集合中都存在一个项目,则更新后的集合中将仅出现一次该项目。
 把集合 y 中的项目插入集合 x:
 x = {"apple", "banana", "cherry"}
 y = {"google", "microsoft", "apple"}
 x.update(y) 
 print(x)

 

    • intersection 交集

 

 s1 = {"刘能", "赵四", "⽪⻓⼭"}
 s2 = {"刘科⻓", "冯乡⻓", "⽪⻓⼭"}
 s3 = s1 & s2                 # 方式一:取两个集合的交集
 s4 = s1.intersection(s2)) # 方式二:取两个集合的交集
 print(s3,s4)

 

    • union 并集

 

 s1 = {"刘能", "赵四", "⽪⻓⼭"}
 s2 = {"刘科⻓", "冯乡⻓", "⽪⻓⼭"}
 s3 = s1 | s2               # 方式一:取两个集合的并集
 s4 = s1.union(s2))         # 方式二:取两个集合的并集
 print(s3,s4)

 

    • difference 差集

 

 s1 = {"刘能", "赵四", "⽪⻓⼭"}
 s2 = {"刘科⻓", "冯乡⻓", "⽪⻓⼭"}
 s3 = s1 - s2                   # 方式一:差集,s1中有且s2中没有的值
 s4 = s1.difference(s2)         # 方式二:差集,s1中有且s2中没有的值
 print(s3,s4)
 s5 = s2 - s1                   # 方式一:差集,s2中有且s1中没有的值
 s6 = s2.difference(s1)         # 方式一:差集,s2中有且s1中没有的值
 print(s5,s6)

symmetric_difference 返回两个集合中不重复的元素集合,即会移除两个集合中都存在的元素。
 x = {"apple", "banana", "cherry"}
 y = {"google", "runoob", "apple"}
 z = x.symmetric_difference(y) 
 print(z)

7.3 转换

其他类型如果想要转换为集合类型,可以通过set进行转换,并且如果数据有重复自动剔除。

提示:int/list/tuple/dict都可以转换为集合。

v1 = [11,22,33,11,3,99,22]
v2 = set(v1)
print(v2) # {11,22,33,3,99}
v1 = "武沛齐"
v2 = set(v1)
print(v2) # {"武","沛","齐"}
v1 = (11,22,3,11)
v2 = set(v1)
print(v2) # {11,22,3}
v1 = {"age":12, "status":True,"name":"武沛齐"}
print( set(v1.keys()) )     # 输出:{'status', 'name', 'age'}
print( set(v1.values()) )    # 输出:{'status', 'name', 'age'}
print( set(v1.items()) )    # 输出:{('age', 12), ('status', True), ('name', '武沛齐')}

7.4 其他

索引/切片/步长
集合中没有提供 索引/切片/步长 这些功能,因为他无需,所以无法使用索引操作。
获取集合长度
v = {"刘能", "赵四", "尼古拉斯")
data = len(v)
print(data)
for循环
 v = {"刘能", "赵四", "尼古拉斯")
 for item in v:
     print(item)

总结

str

  • 独有
    upper,lower,strip,replace,join,format,isdigit,startswith,endswith,isdecimal,encode
  • 公共
    长度,索引,切片,步长,for循环

list

  • 独有
    append,insert,extend,remove,pop,clear,reverse,sort,list
  • 公共
    长度,索引,切片,步长,for循环,删除,替换,嵌套

tuple

  • 独有
  • 公共
    长度,索引,切片,步长,for循环
  • 强制转换
    tuple

dict

  • 独有
    keys/values/items/get/pop/update
  • 公共
    长度,索引(键),修改,del,for循环,嵌套

set

  • 独有
    add,discard,update,intersection,union,difference,symmetric_difference
  • 公共
    长度,for循环

常见的类型转换

#字符串转数字
#数字转字符串
#列表转元组
#元组转列表
#其他转bool时,只有:0 “” [] ()

点赞

发表评论

电子邮件地址不会被公开。必填项已用 * 标注