Python 入门之Python基础数据类型及其方法

目录

Python 入门之Python基础数据类型

1、 整型:int

用于计算,用于比较 (在赋值的时候先执行等号右边的内容)

1.1 整数的加

a = 10
b = 20
print(a + b)
结果:
30

1.2 整数的减

a = 10
b = 20
print(b - a)
结果
10

1.3 整数的乘

a = 10
b = 20
print(a * b)
结果:
200

1.4 整数的除

a = 10
b = 20
print(b / a)
结果:
2.0
# 注意点:当我们使用Python3的时候我们除法获取到时浮点数,也就是小数,但是使用Python2的时候使用除法获取的就是整数

1.5 整数的整除

a = 10
b = 20
print(b // a)
结果:
2

1.6 整数的取余

a = 5
b = 2
print(a % b)
结果:
1

1.7 整数的次方(幂)

a = 5
b = 2
print(a ** b)
结果:
25

​ (python3除法的时候返回的是小数(浮点数),Python2除法的时候返回的是整数(向下取整))

在32位机器上int的范围是: -231~231-1,即-2147483648~2147483647

在64位机器上int的范围是: -263~263-1,即-9223372036854775808~9223372036854775807

整型在Python2和Python3中的区别:

Python3:全部为整型

Python2:整型,长整型long

1.8 10进制转2进制的转换

1.8.1 10进制转2进制:bin()函数

​ 方法:除2求余,从下往上写

print(bin(30))

1.8.2 2进制转10进制:int(“11011101”,2)函数

​ 方法:当前位置上的数乘以2的位数减1次方,并相加即可

print(int("111110",2))

2、布尔值:bool

true — 真 false — 假 :(用于判断)

print(3 > 2)         # 输出借结果为True
print(3 < 2)        # 输出结果为False

3、字符串:str

用于存储一些数据,存储少量数据。在Python中只要是用引号引起来就是字符串,字符串中的每一个字母或者字符都称为元素(字符串拼接:字符串+字符串 字符串翻倍:字符串*数字)

a = """absc"""
print(a)

3.1 字符串加法

#字符串的拼接
s1 = 'a' 
s2 = 'bc'
print(s1 + s2)

3.2 字符串乘法(乘法的规则:只能是字符串和数字相乘)

str*int name = '小强'
print(name*8)

字符串中是不能进行减法和除法操作的

3.3 索引(下标):

<1> 从左向右排(正向索引从0开始)

<2> 从右向左排(反向索引从-1开始)

a = "hello_wiu_srr,_taa_ba_hello"
print(a[5])
print(a[6])
print(a[11])
print(a[-2])
print(a[-1])

索引的时候不能超出索引最大值

3.4 切片:

[起始位置(包含):终止位置(不包含)] :顾头不顾尾

[起始位置:] :从起始默认到最后

[:] :默认从最开始到最后

切片的时候可以超出索引值

a = "hello_wiu_srr,_taa_ba_hello"
print(a[21:100])
print(a[21:])    # [21(起始位置):(默认到最后)]
print(a[:])      # [(默认从最开始):(默认到最后)]

3.5 步长:

步长决定查找方向,以及查找时迈的步子

切片的时候步长默认为1

正数为正向索引(从左向右),负数为反向索引(从右向左)

在结束位置内:起始位置+步长得到下一字符元素

[::-1] :将字符串反向输出

a = "hello_wiu_srr,_taa_ba_hello"
print(a[1:8:2]) 
print(a[1:8:4]) 
print(a[-12:-3:2])  
print(a[10:-5:1])
print(a[-5:-10:-1])

字符串是不可变数据类型,字符串是有序的

3.6 字符串的方法:

<1> upper() :全部大写

name = "maex"
a = name.upper()  # 全部大写
print(a)
print(name)

<2> lower() :全部小写

name = "MAEX"
a = name.lower()   # 全部小写
print(name)
print(a)

<3> startswith() :以什么开头

name = "maex"
print(name.startswith('e',2,3))  # 以什么开头 -- 返回的是布尔值

<4> endswith() :以什么结尾

name = "maex"
print(name.endswith('l',0,2))    # 以什么结尾 -- 返回的是布尔值

<5> count() :统计,计数

name = "maexwauisrtaaibbIa"
print(name.count("i"))      # 统计,计数

<6> strip() :脱(脱头尾两端的空格,换行符\n,制表符\t);去除头尾两端指定内容

pwd = " wslexsdsb   "
a = pwd.strip()   # 脱 默认脱(脱头尾两端的空格,换行符\n,制表符\t)
print(a)
pwd = "alxasdsbala"
a = pwd.strip("al")  # 去除头尾两端指定的内容
print(a)

<7> split() :分割(默认空格,换行符\n,制表符\t);也可以以指定的元素分割。可以指定分割的次数

name = "allwex_wusu_sdi_r"
a = name.split("_")        # 分割(默认空格,换行符\n,制表符\t)
print(a)                  
print(name.split("_",2))   # 可以指定分割的次数

<8> replace() :替换. Replace(“要被替换的内容”,”替换为的内容”,替换次数)

name = "alex,wusir,ta,i,b,a,i"
a = name.replace(",",".")               # 全部替换
print(a)
a = name.replace(",",".",4)              # 可以指定替换的次数
print(a)

3.7 字符串格式化:

format() :按照位置顺序进行填充;按照索引填充;按照名字进行新填充

name = "{}今年:{}".format("宝元",18)    # 按照位置顺序进行填充
print(name)
name = "{1}今年:{0}".format("宝元",18)    # 按照索引进行填充
print(name)
name = "{name}今年:{age}".format(name="宝元",age=18)    # 按照名字进行填充
print(name)

3.8 is 系列 是进行判断 返回的是布尔值

(1)isdigit() :判断字符串中的内容是不是全都是数字(阿拉伯数字)

msg = "alex"
print(msg.isdigit())      # 判断字符串中的内容是不是全都是数字(阿拉伯数字)

(2)isdecimal() :判断是不是十进制数

msg = "alex"
print(msg.isdecimal())    # 判断是不是十进制数

(3)isalnum() :判断是不是数字,字母,中文

msg = "alex"
print(msg.isalnum())      # 判断是不是数字,字母,中文

(4)Isalpha() :判断是不是字母,中文

msg = "alex"
print(msg.isalpha())      # 判断是不是字母,中文

3.9 str数据类型方法—补充:

<1> 字符串名.capitalize() :首字母大写

a = "alex Wusir"
print(a.capitalize())   # 首字母大写

<2> 字符串名.title() : 每个单词首字母大写

a = "alex Wusir"
print(a.title())        # 每个单词首字母大写

<3> 字符串名.swapcase() : 大小写调换

a = "alex Wusir"
print(a.swapcase())     # 大小写转换

<4> 字符串名.center() : 居中 填充

a = "alex Wusir"
print(a.center(20,"*"))     # 居中 - 填充

<5> 字符串名.find() : 查找 通过元素查找索引,查找不到时返回-1

a = "alex Wusir"
print(a.find("c"))        # 查找 通过元素查找索引,查找不到时返回-1

<6> 字符串名.index() : 查找 通过元素查找索引,查找不到时就报错

a = "alex Wusir"
print(a.index("c"))       # 查找 通过元素查找索引,查找不到时就报错

<7> “进行拼接的元素”.join([“1″,”2″,”3”]) : 拼接 ,将列表转换成字符串 (int型无法直接进行拼接)

a = "alex Wusir"
print(a.join("_"))
lst = ["1","2","4"]
print("_".join(lst))  # 拼接,将列表转换成字符串

<8>str + str

name1 = "al"
name2 = "au"
print(id(name1))
print(id(name2))
print(id(name1 + name2))

<9>str * 数字

name1 = "al"
print(id(name1))
print(id(name1 * 5))

(字符串进行加操作,乘操作都是开辟新的空间)

4、列表:list

​ 列表是Python中的数据类型之一,能够存储大量的不同类型的数据。在别的语言中称为数组。32位python的限制是 536870912 个元素,64位python的限制是 1152921504606846975 个元素。而且列表是有序的,有索引值,可切片,方便取值

4.1 定义一个列表: lst = [ ]

lst = [1,2,"alex",True,["钥匙","门禁卡",["银行卡"]]]
print(lst)

列表 — 容器

列表是一种有序的容器, 支持索引

列表是一种可变的数据类型 原地修改

列表中以逗号分割开的才是一个元素

4.2 列表的索引

列表和字符串一样也拥有索引:

lst = ['刘德华','周润发','周杰伦','向华强']
print(lst[0])  # 列表中第一个元素
print(lst[1])  # 列表中第二个元素
print(lst[2])  # 列表中第三个元素

注意:列表是可以进行修改的,这里和字符串不一样

lst[3] = '王健林'
print(lst)

字符串修改

s = '王思聪'
s[0] = '李'
print(s)
结果:
Traceback (most recent call last):
  File "D:/python_object/path2/test.py", line 1076, in <module>
    s[0] = '李'
TypeError: 'str' object does not support item assignment

4.3 列表的切片

lst = ["麻花藤", "王剑林", "马芸", "周鸿医", "向华强"] 
print(lst[0:3])     # ['麻花藤', '王剑林', '马芸'] 
print(lst[:3])      # ['麻花藤', '王剑林', '马芸']
print(lst[1::2])    # ['王剑林', '周鸿医'] 也有步长 
print(lst[2::-1])   # ['马芸', '王剑林', '麻花藤'] 也可以倒着取 
print(lst[-1:-3:-2])    # 倒着带步长

4.4 列表的增加:

<1> append() :追加 在最末尾的地方进行添加 append(追加的内容)

lst = [1,2,3,4,3]
lst.append(13)   # 追加  在最末尾的地方进行添加print(lst)

<2> insert() :插入 insert(插入的位置,“插入的内容”) 尽量减少使用,会使效率下降

lst = [1,2,3,4,3]
lst.insert(2,"ro")       # 插入
print(lst)

<3> extend() :迭代添加 一个一个添加

lst = [1,2,3,4,3]
lst.extend([1,2,3,4])       # 迭代添加(一个一个添加)
print(lst)

4.5 列表的删除:

<1> remove() :只能删除一个,从左向右删除。通过元素的名字进行删除

lst = [1,2,3,4,3]
list.remove(1)    
print(lst)

<2> pop() :弹出 默认删除最后一个,并且具有返回值,返回值为弹出的那个。也可以加下标进行删除pop(3)。Repr() :查看当前数据的源生态

lst = [1,2,3,4,3]
print(repr(lst.pop(2)))    # repr()查看当前数据的原生态
print(lst)

<3>clear() :清空

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

<4> del() :直接在内存空间中删除。可通过索引,切片,步长删除

lst = [1,2,3,4,3]
del lst[4]    # 通过索引删除
del lst[2:5]    # 通过切片删除
del lst[1:5:2]      # 通过步长删除
print(lst)

4.6 列表的修改:

<1> lst[2] = 80 :通过索引进行修改

lst = [1,2,3,4,5]
lst[2] = 80    # 通过索引进行修改
print(lst))

<2> Lst[1:3] = “skaj” :通过切片进行修改,必须是可迭代的对象。默认步长为1,修改的内容可多可少

lst = [1,2,3,4,5]
lst[1:3] = "20"  # 通过切片进行修改,默认步长为1,修改的内容必须是可迭代的对象,修改的内容可多可少
print(lst)

<3> Lst[1:5:2] = “10” :通过步长进行修改,步长不为1的时候,必须一一对应

lst = [1,2,3,4,5]
lst[1:5:2] = 100,100    # 步长不为1的时候,必须一一对应print(lst)

4.7 列表的查找:

<1> 通过索引进行查找

<2> for循环

lst = [1,2,3,4,5]
    for i in lst:
        print(i)

4.8 列表的嵌套:

lst = [1,2,[3,4,5,["alex[]",True,[[1,2,]],90],"wusir"],"taibai"]
lst1 = lst[2]   # [3, 4, 5, ['alex[]', True, [[1, 2]], 90], 'wusir']
lst2 = lst1[3]  # ['alex[]', True, [[1, 2]], 90]
str_1 = lst2[0]
print(str_1[-1])
print(lst[2][3][0][-1])

一层一层的查找,[……]视为一个元素

4.9 list数据类型方法—补充:

<1> 列表的定义:list(“123456”)

<2> 列表的方法:

1> 列表名.index() : 通过元素查找索引
lst = [1,23,4,5,7,8,9]
print(lst.index(4))        # 通过元素查找索引
2> 列表名.reverse() : 反转
lst = [1,23,4,5,7,8,9]
lst.reverse()     
print(lst)
3> 列表名.sort() : 排序 默认是升序
lst = [1,23,4,5,7,8,9]
lst.sort()                 # 排序 默认是升序
print(lst)
4> 列表名.sort(reverse=True) : 降序
lst = [1,23,4,5,7,8,9]
lst.sort(reverse=True)     # 降序
print(lst)

试题:

lst = [1,[]] * 5
 print(lst)       # [1, [], 1, [], 1, [], 1, [], 1, []]
 lst[1].append(6)
 print(lst)       # [1, [6], 1, [6], 1, [6], 1, [6], 1, [6]]
列表在进行乘法的时候,元素是共用的

5、元组:tuple

元组是Python中的数据类型之一,它是有序的,不可变的,只支持查询。元组就是一个不可变的列表。

5.1 定义方式: Tu = (1,2,3)

tu = (1,2,"alex",[1,3,4])
print(tu)

5.2元组的统计:

元组.count()

tu = (1,2,3,4,5,1,2,1)
print(tu.count(1))

5.3 元组的获取索引:

元组.index(4) :通过元素查询索引

tu = (1,2,3,4,5,1,2,1)
print(tu.index(2))  # 通过元素查询索引

5.4 元组的用途:

配置文件中使用

5.5 元组的嵌套:

tu = (1,2,3,4,(5,6,7,8,("alex","wusir",[1,23,4])))
print(tu[4][4][0])

(3)Tuple:

试题:

  tu = (1)
     \# tu1 = ("alex")
     \# tu2 = (1,)          #元组

5.6 tuple数据类型方法—补充:

<1> tu + tu

tu = (12,3,4) + (4,5,3,4)
print(tu)

<2> tu * 数字

tu = (1,[]) * 3
print(tu)
tu[-1].append(10)
print(tu)
元组在进行乘法的时候,元素是共用的

6、字典 – dict

字典是Python的中的数据结构之一,是一种无序的,可变的数据类型,字典中的所有操作都是通过键。

6.1 定义: dic = {“key”:”value”} — 键值对

6.2 字典的作用:

存储大大量数据,将数据和数据起到关联作用

dic = {"10":"苹果手机",
       "11":"苹果手机",
       15:"小米手机",
       15:"华为手机",
       (1,):"oppo手机",
       }
print(dic)
键:必须是不可变的数据类型(可哈希),且唯一
值:任意,可变(不可哈希)

6.3 字典的增:

<1> 暴力添加:

dic[“ 键”] = “值” //字典的添加,添加的是一个键值对
dic = {
       "日魔":["看动漫","健身","吃包子","吃大煎饼","吃大烧饼"],
       "炮手":"飞机",
       "豹哥":"贴膏药",
       "宝元":"宝剑",
       "alex":"吹牛逼"
}
dic["日阳"] = "小明"  # 字典的添加,添加的是一个键值对
dic["小妹"] = ["听歌","唱歌","吃","烤馕","大盘鸡","葡萄干"]
print(dic)
<2> dic.setdefault(“键”,[“值1”,”值2”] //有则不添加,无则添加:
先查看键是否存在字典
不存在的时候进行添加
dic = {
       "日魔":["看动漫","健身","吃包子","吃大煎饼","吃大烧饼"],
       "炮手":"飞机",
       "豹哥":"贴膏药",
       "宝元":"宝剑",
       "alex":"吹牛逼"
}
dic.setdefault("元宝",["唱","跳","篮球","喝酒"])
print(dic)

6.4 字典的删除:

<1> pop() : //pop删除通过字典中的键进行删除,返回的也是被删除的值

dic = {
              "日魔":["看动漫","健身","吃包子","吃大煎饼","吃大烧饼"],
              "炮手":"飞机",
              "豹哥":"贴膏药",
              "宝元":"宝剑",
              "alex":"吹牛逼"
       }
print(dic.pop("宝元"))  #pop删除通过字典中的键进线删除 返回的也是被删除的值
print(dic)

<2> clear() : //清空

dic = {
              "日魔":["看动漫","健身","吃包子","吃大煎饼","吃大烧饼"],
              "炮手":"飞机",
              "豹哥":"贴膏药",
              "宝元":"宝剑",
              "alex":"吹牛逼"
       }
dic.clear()      # 清空
print(dic)

<3> del dic: //删除的是整个字典容器

dic = {
              "日魔":["看动漫","健身","吃包子","吃大煎饼","吃大烧饼"],
              "炮手":"飞机",
              "豹哥":"贴膏药",
              "宝元":"宝剑",
              "alex":"吹牛逼"
       }
del dic          # 删除的是整个容器
print(dic)

<4> del dic[“键”] : //通过键进行删除

dic = {
              "日魔":["看动漫","健身","吃包子","吃大煎饼","吃大烧饼"],
              "炮手":"飞机",
              "豹哥":"贴膏药",
              "宝元":"宝剑",
              "alex":"吹牛逼"
       }
del dic["alex"]  # 通过键进行删除
print(dic)
字典中没有remove

6.5 字典的改:

<1> dic[“键”] = “值” : //有则就覆盖,没有就添加

dic = {
              "日魔":["看动漫","健身","吃包子","吃大煎饼","吃大烧饼"],
              "炮手":"飞机",
              "豹哥":"贴膏药",
              "宝元":"宝剑",
              "alex":"吹牛逼"
       }
dic["alex"] = "dsb"   # 有则就覆盖,没有添加
print(dic)

<2> update(新字典) : //update函数后面的字典级别高于前面的字典

dic = {
              "日魔":["看动漫","健身","吃包子","吃大煎饼","吃大烧饼"],
              "炮手":"飞机",
              "豹哥":"贴膏药",
              "宝元":"宝剑",
              "alex":"吹牛逼"
       }
dic1 = {"alex":"上过北大","wusir":"干过前端"}
dic1.update(dic)
print(dic1)

6.6 字典的查:

<1> get (”键”) : //查询不到时返回None get(“键”,”自己指定的内容”):当查询不到时返回自己指定的内容

dic = {
       "日魔":["看动漫","健身","吃包子","吃大煎饼","吃大烧饼"],
       "炮手":"飞机",
       "豹哥":"贴膏药",
       "宝元":"宝剑",
       "alex":"吹牛逼"
}
print(dic.get("alex"))   # 查询不到返回None
print(dic.get("元宝","找不到啊")) # 查找不到的时候返回自己制定的内容

<2> setdefault(“键”) : // 查询不到时返回None

dic = {
       "日魔":["看动漫","健身","吃包子","吃大煎饼","吃大烧饼"],
       "炮手":"飞机",
       "豹哥":"贴膏药",
       "宝元":"宝剑",
       "alex":"吹牛逼"
}
print(dic.setdefault("alex"))  # 查询不到返回None

<3> dic[“键”] : //查询不到就报错

dic = {
       "日魔":["看动漫","健身","吃包子","吃大煎饼","吃大烧饼"],
       "炮手":"飞机",
       "豹哥":"贴膏药",
       "宝元":"宝剑",
       "alex":"吹牛逼"
}
print(dic["alex"])       # 查询不到就报错了

<4> dic.keys() : //查看键 获取到的是一个高仿列表

dic = {
       "日魔":["看动漫","健身","吃包子","吃大煎饼","吃大烧饼"],
       "炮手":"飞机",
       "豹哥":"贴膏药",
       "宝元":"宝剑",
       "alex":"吹牛逼"
}
for i in dic:   # 查看所有的键
    print(i)
print(dic.keys())   # 获取到的是一个高仿列表

<5> dic.values() : //查看值, 获取到的是一个高仿列表

dic = {
       "日魔":["看动漫","健身","吃包子","吃大煎饼","吃大烧饼"],
       "炮手":"飞机",
       "豹哥":"贴膏药",
       "宝元":"宝剑",
       "alex":"吹牛逼"
}
for i in dic:   # 查看所有的值
    print(dic.get(i))
print(dic.values()) # 获取到的是一个高仿列表

高仿列表支持迭代,不支持索引

for i in dic.values(): # 高仿列表支持迭代
    print(i)

<6> items() : //查看键值对

dic = {
       "日魔":["看动漫","健身","吃包子","吃大煎饼","吃大烧饼"],
       "炮手":"飞机",
       "豹哥":"贴膏药",
       "宝元":"宝剑",
       "alex":"吹牛逼"
}
for i in dic.items():
    print(i[0],i[1])

6.7 字典的嵌套:

字典嵌套查找的时候一定是按照一层一层进行查找

dic = {
    101:{1:{"日魔":"对象"},
         2:{"隔壁老王":"王炸"},
         3:{"乔碧萝":("日魔","炮手","宝元")},
         },
    102:{1:{"汪峰":{"国际章":["小苹果","大鸭梨"]}},
         2:{"邓紫棋":["泡沫","信仰","天堂","光年之外"]},
         3:{"腾格尔":["隐形的翅膀","卡路里","日不落"]}
         },
    103:{1:{"蔡徐坤":{"唱":["鸡你太美"],
                   "跳":["钢管舞"],
                   "rap":["大碗面"],
                   "篮球":("NBA形象大使")}},
         2:{"JJ":{"行走的CD":["江南","曹操","背对背拥抱","小酒窝","不潮不花钱"]}},
         3:{"Jay":{"周董":["菊花台","双节棍","霍元甲"]}}},
    201:{
        1:{"韦小宝":{"双儿":"刺客","建宁":{"公主":{"吴三桂":"熊"}},"龙儿":{"教主老婆":"教主"}}}
    }
}
print(dic[201][1]["韦小宝"]["建宁"]["公主"]["吴三桂"])
print(dic[103][1]["蔡徐坤"]["跳"][0][1])
print(dic[102][2]["邓紫棋"][1])

6.8 dict数据类型方法—补充:

<1> 字典名.popitem() :随机删除,并返回的是被删除的键值对 Python3.6版删除最后一个键值对

dic = {"key":1,"key1":2,"key2":4,"key3":1}
print(dic.popitem())   # 随机删除  python3.6版删除最后一个键值对    # popitem返回的是被删除的键值对
print(dic)

<2> 字典名.fromkeys(“abc”,[]) : 批量创建键值对“a”:[],“b”:[],“c”:[]

试题:

dic = {}
     dic.fromkeys("abc",[])   # 批量创建键值对 
     print(dic)
fromkeys第一个参数必须是可迭代的对象,会将可迭代的对象进行迭代,成为字典的键。第二个参数是值(这个值是共用的)
fromkeys共用的值是可变数据类型就会有坑,不可变数据类型就没事
dic = {}
dic = dic.fromkeys("abc",[])
print(dic)
dic["b"] = 11
dic["a"].append(10)
print(dic)

7、集合:

集合是Python中的数据类型之一,是无序的,可变的且唯一。集合就是一个没有值的字典,集合天然去重。

试题:用一行代码去重

lst = [1,223,1,1,2,31,231,22,12,3,14,12,3]
print(list(set(lst)))

7.1 定义一个空集合 : set1 = set{}

7.2 集合的增:

<1> 集合名.add()

s = set()
s.add("alex")
print(s)

<2> 集合名.update() : 迭代添加

s = set()
s.update("wusir")  # 迭代添加
print(s)

7.3 集合的删:

<1 >集合名.remove() :通过元素删除

s = {100,0.1,0.5,1,2,23,5,4}
s.remove(4)    # 通过元素删除
print(s)

<2> 集合名.clear() : 清空

s = {100,0.1,0.5,1,2,23,5,4}
s.clear()  # 清空
print(s)

<3>集合名.pop() : 随即删除(一般情况下是最小的)

s = {100,0.1,0.5,1,2,23,5,4}
s.pop()      # 随机删除 (一般是最小的)
print(s)

7.4 集合的改:

先删后加

s = {1,2,3,4,5}              # 先删后加

7.5 集合的查:

for循环

7.6 集合的其他操作:

(1)差集 –

s = {1,23,9,4,5,7}
s1 = {1,2,3,4,5}
print(s - s1)
print(s1 - s)

(2)交集 &

s = {1,23,9,4,5,7}
s1 = {1,2,3,4,5}
print(s & s1)

(3)并集 |

s = {1,23,9,4,5,7}
s1 = {1,2,3,4,5}
print(s | s1)

(4)反交集 ^

s = {1,23,9,4,5,7}
s1 = {1,2,3,4,5}
print(s ^ s1)

(5)子集 < : 返回的是一个布尔值

s = {1,23,9,4,5,7}
s1 = {1,2,3,4,5}
print(s < s1)

(6)父集(超级) > :

s = {1,23,9,4,5,7}
s1 = {1,2,3,4,5}
print(s1 > s)

(7)冻结集合 frozenset

s = {1,23,9,4,5,7}
s1 = {1,2,3,4,5}
dic = {frozenset({1,23,4,5}):123}
print(dic)

https://www.cnblogs.com/caiyongliang/p/11408782.html

「点点赞赏,手留余香」

    还没有人赞赏,快来当第一个赞赏的人吧!
Python
0 条回复 A 作者 M 管理员
    所有的伟大,都源于一个勇敢的开始!
欢迎您,新朋友,感谢参与互动!欢迎您 {{author}},您在本站有{{commentsCount}}条评论