Python数据类型之基础记。。。

数据类型

1、什么是数据？为何要有数据？

==>    x=10，10是我们要存储的数据 。数据是用来表示状态的，不同的状态就应该用不同的类型的数据去表示

2、数据类型

A*数字（整型，长整型，浮点型，复数）

B*字符串

C*列表

D*元组

E*字典

F*集合

3、数据的使用一般是按照以下几点展开

#======================================基本使用======================================
#1、用途
?
#2、定义方式
?
#3、常用操作+内置的方法
?
#======================================该类型总结====================================
#存一个值or存多个值
    
#有序or无序
?
#可变or不可变（1、可变：值变，id不变。可变==不可hash 2、不可变：值变，id就变。不可变==可hash）

#AAA* 一：整型int
?
# ======================================基本使用======================================
?
# 1、用途：年龄、个数、号码、出生年等
?
# 2、定义方式
?
# age = 18  # age = int(18)
?
# int功能可以把纯数字的字符串转换成int类型
?
# res = int("18")
?
# # res = int("1.8")
?
# print(type(res))
?
# 了解（***）
?
# print(bin(11))  # 0b1011
?
# print(oct(11))  # 0o13
?
# print(hex(11))  # 0xb
?
# 3、常用操作+内置的方法
?
# 算数运算符与比较运算
?
# 二：浮点型float
?
# ======================================基本使用======================================
?
# 1、用途：薪资、身高、体重等
?
# 2、定义方式
?
salary = 3.1  # salary = float(3.1)
?
# float功能可以把浮点数组成的字符串转换成float类型
?
# res = float("1.8")
?
# print(type(res))
?
?
# 3、常用操作+内置的方法
?
# 算数运算符与比较运算
?
# ======================================该类型总结====================================
?
# 存一个值
?
# 不可变

# ======================================基本使用======================================
?
#BBB 1、用途：记录描述性质的状态，例如名字、性别、国籍等
?
# 2、定义方式：在引号（‘‘，"",‘‘‘‘‘‘,"""""""）内包含一串字符串
?
s = "hello"  # s = str("hello")
?
# str功能可以把任意类型转换成str类型
?
# res=str([1,2,3])  # "[1,2,3]"
?
# print(type(res))
?
# 3、常用操作+内置的方法
?
# =======================>优先掌握的操作：
?
# 1、按索引取值(正向取+反向取) ：只能取
?
s = "hello world"
?
# print(s[0],type(s[0]))  # "h"
?
# print(s[-1])
?
# s[1] = "E"  # 不能修改
?
# 非法操作
?
# s[2222]
?
# s[11] = "A"
?
# 2、切片(顾头不顾尾，步长)=>属于拷贝操作
?
s = "hello world"
?
# new_s=s[1:7]
?
# print(new_s)
?
# print(s)
?
# new_s=s[1:7:2]  #1 3 5
?
# print(new_s)
?
# print(s)
?
# new_s=s[:7:2]
?
# new_s=s[::2]  # 0 2 4 6 8 10
?
#               h l o w r  d
?
# print(new_s)
?
# new_s=s[::]  # 完整拷贝字符串，只留一个冒号就可以new_s=s[:]
?
# print(new_s)
?
?
# 3、长度len
?
# s = "hello world"
?
# print(len(s))
?
# res=print("sfd")
?
# print(res)
?
# 4、成员运算in和not in
?
# s = "hello world"
?
# # print("hel" in s)
?
# print("egon" not in s) # 语义明确，推荐使用
?
# # print(not "egon" in s)
?
# 5、移除空白strip
?
# s = " \n        hel lo  \t "
?
# new_s = s.strip()
?
# print(new_s)
?
# print(s)  # 没有改变原字符串
?
# 应用案列：
?
# name = input("your name>>> ").strip()  # name = "egon "
?
# pwd = input("your pwd>>> ").strip()
?
#
?
# if name == "egon" and pwd == "123":
?
#     print(‘login successful‘)
?
# else:
?
#     print(‘user or password error‘)
?
?
# 去除左右两边的非空白字符
?
# print("**+=-%^#****he**llo**%^#**+=**".strip("*+=-%^#"))
?
# 6、切分split：把字符串按照某个分隔符切成一个列表
?
# userinfo = "egon_dsb:123:18:3.1"
?
# res = userinfo.split(":")
?
# # print(res[0])
?
# print(res)
?
# print("-".join(res))
?
# 纯字符串组成的列表
?
# l = ["aaaa", "bbb", "ccc"]
?
#
?
# # res=l[0]+":"+l[1]+":"+l[2]
?
# res = ":".join(l)
?
# print(res, type(res))
?
# 7、循环
?
# for i in "hello":
?
#     print(i)
?
?
# =======================>需要掌握的操作：
?
# 1、strip,lstrip,rstrip
?
# print("***hello***".strip("*"))
?
# print("***hello***".lstrip("*"))
?
# print("***hello***".rstrip("*"))
?
# 2、lower,upper
?
# msg = "AbCDEFGhigklmn"
?
# res = msg.lower()
?
# res = msg.upper()
?
# print(res)
?
# res=msg.swapcase()
?
# print(res)
?
# 3、startswith,endswith
?
# msg = "sb is lxx sb"
?
# print(msg.startswith("sb"))
?
# print(msg.endswith("b"))
?
# print(msg.endswith("c"))
?
# 5、split,rsplit
?
# userinfo="egon:123:18"
?
# # print(userinfo.split(":"))
?
# print(userinfo.split(":",1))
?
# print(userinfo.rsplit(":",1))
?
# 6、join
?
# 7、replace
?
msg = "***egon hello***"
?
# res=msg.replace(‘*‘,‘‘).replace(‘ ‘,‘‘)
?
# res=msg.strip(‘*‘).replace(‘ ‘,‘‘)
?
# print(res)
?
# s="lxx hahah wocale lxx sb 666"
?
# # res=s.replace(‘lxx‘,‘sb‘)
?
# res=s.replace(‘lxx‘,‘sb‘,1)
?
# print(res)
?
# print(s)
?
# 4、format的三种玩法
?
# 4.1 %s的方式
?
# name = "egon"
?
# age = 18
?
# res1="my name is %s my age is %s" % (name,age)
?
# print(res1)
?
# 4.2 format的方式
?
# name = "egon"
?
# age = 18
?
# res1="my name is {} my age is {}".format(name,age)
?
# res1="{0}{0}{0}{1}".format(name,age)
?
# res1="my name is {name} my age is {age}".format(age=18,name="egon")
?
# print(res1)
?
# 4.3 f.txt‘‘
?
# name = "egon"
?
# age = 18
?
# res1 = f.txt"my name is {name} my age is {age}"
?
# print(res1)
?
?
# 了解：f搭配{}可以执行字符串中的代码
?
# res=f.txt‘{len("hello")}‘
?
# print(res)
?
# f.txt‘{print("hello")}‘
?
# f包含的字符串可以放到多行
?
# name = "egon"
?
# age = 18
?
# res1 = f.txt"my name is {name} " \
?
#        f.txt"my age is {age}"
?
# {}内不能有\以及#
?
# print(f.txt‘my name is {{egon}}‘)
?
# print(‘胜率是 %s%%‘ %70)
?
# 了解：https://zhuanlan.zhihu.com/p/110406030
?
# 8、isdigit:判断字符串是否由纯数字组成
?
# print("adsf123".isdigit())
?
# print("123".isdigit())
?
# print("12.3".isdigit())
?
age = input(‘>>>: ‘) # age = "        18     "
if age.isdigit():
    age=int(age)
    if age > 18:
        print(‘猜大了‘)
    elif age < 18:
        print(‘猜小了‘)
    else:
        print(‘猜对了‘)
else:
    print(‘必须输入数字，小垃圾‘)
?
# =======================>了解的操作：
?
?
# ======================================该类型总结====================================
?
# 存一个值or存多个值
?
# 有序or无序
?
# 可变or不可变（1、可变：值变，id不变。可变==不可hash 2、不可变：值变，id就变。不可变==可hash）

#1、find,rfind,index,rindex,count（字符串内置方法）

# x = "hello egon egon egon"
?
# res=x.find("egon")
?
# res=x.find("egon123") # -1代表没有找到
?
# print(res)
?
# res=x.rfind("egon")
?
# print(res)
?
# res=x.find("egon",0,3)
?
# print(res)
?
?
# res = x.index("egon123") # 找不到则报错
?
# print(res)
?
?
?
#2、center,ljust,rjust,zfill
?
# x = "egon"
?
# res=x.center(50,‘*‘)
?
# print(res)
?
# print(x.ljust(50,"*"))
?
# print(x.rjust(50,"*"))
?
# print(x.zfill(50))
?
# print(x.rjust(50,"0"))
?
#3、expandtabs
?
# print("hello\tworld".expandtabs(1))
?
#4、captalize,swapcase,title
?
# print("hello world egon".capitalize())
?
# print("aBcDeF".swapcase())
?
# print("hello world egon".title())
?
?
#5、is其他
?
# name=‘egon123‘
?
# print(name.isalnum()) #字符串由字母或数字组成
?
# print(name.isalpha()) #字符串只由字母组成
?
#
?
# name="aaainputbbbbb"
?
# print(name.isidentifier())
?
# name="abc123"
?
# print(name.islower())
?
# print(name.isupper())
?
# name="     "
?
# print(name.isspace())
?
# name="My Name Is Egon"
?
# print(name.istitle())
?
#6、is数字系列
#在python3中
num1=b‘4‘ #bytes
num2=u‘4‘ #unicode,python3中无需加u就是unicode
num3=‘四‘ #中文数字
num4=‘Ⅳ‘ #罗马数字
?
#1、 bytes、unicode
?
# print(num1.isdigit())
?
# print(num2.isdigit())
?
# print(num3.isdigit())
?
# print(num4.isdigit())
?
?
# 2、unicode、中文数字、罗马数字
?
# print(num2.isnumeric())
?
# print(num3.isnumeric())
?
# print(num4.isnumeric())
?
# 3、unicode
?
# print(num2.isdecimal())
?
# print(num3.isdecimal())
?
# print(num4.isdecimal())
?
?
# ======================================该类型总结====================================
?
# 存一个值
?
# 有序
?
# 不可变
?
# x="hello"
?
# x[0]="H"

CCC列表类型

# ======================================基本使用======================================
?
# 1、用途：按照索引存放多个任意类型的值，索引反映的是位置/顺序
?
# 2、定义方式：在[]内用逗号分割开多个任意类型的元素
?
# l=[111,1.1,"aaa",[2222,3333]]  # l=list([111,1.1,"aaa",[2222,3333]])
?
# print(type(l))
?
# 数据类型转换
?
# res=list("hello")
?
# res=list({"k1":1,"k2":2,"k3":3})
?
# print(res)
?
# 3、常用操作+内置的方法
?
# ===============3.1 优先掌握的操作：
?
#1、按索引存取值(正向存取+反向存取)：即可以取可以改值,不能加值
l1 = [11,22,33,44,55]
?
# print(l1[0])
?
# print(l1[10])
?
# print(l1[-1])
?
# print(id(l1))
?
# l1[0] = 100
?
# print(id(l1))
?
# l1[5] = 11111
?
# d = {‘k1‘:2}
?
# d[‘kkkk‘]=22222
?
# print(d)
?
#2、切片(顾头不顾尾，步长)
l1 = [11,22,[66,77]]
?
# res=l1[2:4]
?
# print(res)
?
# print(l1)
?
# 2.1 浅copy：
?
# l2=l1[:]
?
# l2=l1.copy()
?
#
?
# print(id(l1[0]),id(l1[1]),id(l1[2]))
?
# print(id(l2[0]),id(l2[1]),id(l2[2]))
?
?
?
?
# l1[0] = "aaa"
?
# l1[1] = "bbb"
?
# l1[2] = "ccc"
?
# l1[2][0] = 8888
?
# print(l2)
?
?
# from copy import deepcopy
?
# l3=deepcopy(l1)
?
# print(id(l3[0]),id(l3[1]),id(l3[2]))
?
#
?
# l1[2][0]=6666
?
# print(l1)
?
# print(l3)
?
# 示范1：
?
# l1[0]=1000
?
# print(l1)
?
# print(l2)
?
# 示范2：
?
# l1[-1][0]=666
?
# print(l1)
?
# print(l2)
?
# 了解：
?
# res=l1[-1:-4:-1]
?
# res=l1[::-1]
?
# print(res)
?
?
#3、长度
?
# l1 = [11,22,[66,77]]
?
# print(len(l1))
?
#4、成员运算in和not in
?
# l1 = [111,22,[66,77]]
?
# print([66,77] in l1)
?
# print(66 in l1)
?
# print(66 not in l1)
?
#5、追加
l1=[11,222]
?
# l1.append(33)
?
# l1.append(44)
?
# l1.append([55,66])
?
# print(l1)
?
# l1.insert(1,"aaa")
?
# print(l1)
?
#6、删除
l1=[11,222,[1,2]]
#6.1 万能删除，没有返回值，代表的是单纯的删除
?
# del l1[0]
?
# print(l1)
?
#6.2 指定元素删除,没有返回值，代表的是单纯的删除
?
# res=l1.remove([1,2])
?
# print(l1)
?
# print(res)
?
#6.3 指定索引删除，有返回值，代表的是取走操作
?
# res=l1.pop(1)
?
# print(l1)
?
# print(res)
?
#7、循环
?
# l1=[11,222,[1,2]]
?
# for x in l1:
?
#     print(x)
?
?
# ===============3.2 需要掌握的操作：
?
l1=[11,22,333,333,333,]
?
# l1.clear()
?
# print(l1)
?
# print(l1.count(333333333))
?
# l2=[444,555]
?
# for item in l2:
?
# #     l1.append(item)
?
# l1.extend(l2)
?
l1.extend("hello")
print(l1)
?
# l1=[11,22,333,333,333,]
?
# res=l1.index(333,0,2)
?
# res=l1.index(444)
?
# print(res)
?
# l1=[11,22,"aaa",‘bbb‘]
?
# l1.reverse()
?
# l1=l1[::-1]
?
# print(l1)
?
# l1 = [11, 22, "aaa", ‘bbb‘]
?
# l1 = [-3,99,12,-5,93]
?
# l1.sort(reverse=True)
?
# print(l1)
?
# ======================================该类型总结====================================
?
# 存一个值or存多个值
?
# 有序or无序
?
可变or不可变（1、可变：值变，id不变。可变==不可hash 2、不可变：值变，id就变。不可变==可hash）
?
?

ddd 元组类型

# 什么是元组？
?
# 元组就是一个不可变的列表
?
#
?
# ======================================基本使用======================================
?
# 1、用途: 按照索引存放多个任意类型的值，索引反应的是位置/顺序
?
# 2、定义方式：在()内用逗号分隔开多个任意类下的值/元素
?
# t=(10)
?
# print(type(t))
?
# 强调:当元组内只有一个元素时，必须加逗号
?
# t=(10,)
?
# print(type(t))
?
# t=(10,1.1,"aaa",[11,22])
?
# print(t[-1][0])
?
# t[0]=11111
?
# t[-1]=333333
?
# t=(11,22,[33,44])
?
# print(id(t[0]),id(t[1]),id(t[2]))
?
#
?
# t[2][0]=333333333
?
# # print(t)
?
# print(id(t[0]),id(t[1]),id(t[2]))
?
# t=(11,22)  # t=tuple(...)
?
# print(type(t))
?
# 类型转换
?
# tuple(所有可以被for循环遍历的类型)
?
# t=()
?
# print(t)
?
# print(type(t))
?
# 3、常用操作+内置的方法
?
#优先掌握的操作：
#1、按索引取值(正向取+反向取)：只能取
?
# t=(10,1.1,"aaa",[11,22])
?
# print(t[0])
?
#2、切片(顾头不顾尾，步长)
?
# t=(11,22,33,44,55)
?
# print(t[0:3])
?
#3、长度
?
# t=(11,22,33,44,55)
?
# print(len(t))
?
#4、成员运算in和not in
?
# t=(11,22,33,44,55)
?
# print(11 in t)
?
#5、循环
?
# for x in t:
?
#     print(x)
?
?
#需要掌握的操作：
?
# t=(11,22,33,44,55)
?
# ======================================该类型总结====================================
?
# 存多个值
?
# 有序
?
不可变（1、可变：值变，id不变。可变==不可hash 2、不可变：值变，id就变。不可变==可hash）

eee 字典类型

# ======================================基本使用======================================
?
# 1、用途：按key:value的形式存放多个任意类型的value，key反映的是value的属性
?
# 2、定义方式：在{}内用逗号分隔开多个key:value，其中value可以是任意类型
?
#            而key必须是不可变的类型，通常是字符串类型
?
# d={‘k1‘:111,‘k1‘:222,‘k1‘:3333}  # key重复，只保留一个
?
# print(d)
?
?
# d={1:"aaa",3.1:‘bbbb‘,[1,2]:"ccc"}
?
# d={1:"aaa",3.1:‘bbbb‘,():"ccc"}  # d=dict(...)
?
# print(type(d))
?
# print(d[()])
?
# 类型转换
?
# l=[("name","egon"),("age",18),["gender","male"]]
?
# res=dict(l)
?
# print(res)
?
# d=dict(x=1,y=2,z=3)
?
# print(d)
?
# 空字典
?
# d={}
?
# print(type(d))
?
# dic={}.fromkeys(["name",‘age‘,"gender"],None)
?
# dic={}.fromkeys("hello",None)
?
# print(dic)
?
?
# 3、常用操作+内置的方法
?
#==========>优先掌握的操作：
#1、按key存取值：可存可取
?
# d={‘k1‘:111}
?
# print(d[‘k1‘])
?
# d[‘k2‘]=222
?
# print(d)
?
#2、长度len
?
# d={‘k1‘:111,‘k2‘:222}
?
# print(len(d))
?
?
#3、成员运算in和not in
?
# d={‘k1‘:111,‘k2‘:222}
?
# print(‘k1‘ in d)
?
# print(111 in d)
?
?
#4、删除
d={‘k1‘:111,‘k2‘:222}
#6.1 万能删除，没有返回值，代表的是单纯的删除
?
# del d[‘k1‘]
?
# print(d)
?
#6.2 随机删,返回一个元组
?
# res=d.popitem()
?
# print(d)
?
# print(res)
?
#6.3 指定key删除，有返回值，代表的是取走操作
?
# res=d.pop(‘k1‘)
?
# print(d)
?
# print(res)
?
#5、键keys()，值values()，键值对items()
"""
?
>>> d={‘k1‘:111,‘k2‘:222}
>>> d.keys()
>>> [‘k2‘, ‘k1‘]
>>> d.values()
>>> [222, 111]
>>> d.items()
>>> [(‘k2‘, 222), (‘k1‘, 111)]
>>> """
?
#6、循环
?
# d={‘k1‘:111,‘k2‘:222}
?
# for k in d:
?
#     print(k)
?
# for v in d.values():
?
#     print(v)
?
# for k,v in d.items():
?
#     print(k,v)
?
# keys=[]
?
# for k in d:
?
#     keys.append(k)
?
keys=list(d.keys())
print(keys)
?
# ======================================该类型总结====================================
?
# 存一个值or存多个值
?
# 有序or无序
?
# 可变or不可变（1、可变：值变，id不变。可变==不可hash 2、不可变：值变，id就变。不可变==可hash）

fff 集合及一些补充知识

# t = (1)
?
# print(t,type(t))
?
# """
?
# 推荐你们在使用容器类型的元素的时候
?
# 如果该容器类型只有一个元素 那么你也习惯性的
?
# 将逗号加上
?
# t = (1,)
?
# l = [‘jason‘,]
?
# """
?
# d = dict(username=‘jason‘, age=18)
?
# print(d)  # {‘username‘: ‘jason‘, ‘age‘: 18}
?
# 类型转换
?
# d1 = dict([[‘username‘,‘password‘],(‘jason‘,123)])
?
# print(d1)  # {‘username‘: ‘password‘, ‘jason‘: 123}
?
# 操作方法
?
# 取值
?
"""
字典默认暴露给外界的可操作的只有字典的key
字典是无需的 根本没有索引一说
?
程序员第一准则
    能少写一个字母绝对不多写一个
"""
d = {‘username‘: ‘jason‘, ‘password‘: 123}
?
# print(d[‘username‘])  # 不推荐使用该方法
?
# print(d[‘xxx‘])  # KeyError: ‘xxx‘
?
# 1 get方法
?
# res = d.get(‘username‘)
?
# print(res)  # jason
?
# res = d.get(‘xxx‘)
?
# print(res)  # None  键不存在会返回None 不会报错
?
# res = d.get(‘username‘, ‘你搞什么飞机 这个键不存在 去你妹啊‘)
?
# print(res)  # 键存在还是返回对应的值
?
# res = d.get(‘xxx‘, ‘你搞什么飞机 这个键不存在 去你妹啊‘)
?
# print(res)  # 键不存在 返回get方法里面第二个参数
?
# 字典新增键值对
?
# 方式1
?
# d[‘hobby‘] = ‘study‘  # 字典的key不存在新增
?
# print(d)
?
# d[‘username‘] = ‘egon‘
?
# print(d)  # 字典的key存在则修改
?
# 方式2
?
# d.update(username=‘jason‘)
?
# print(d)  # 特点同上
?
# 方式3
?
"""
键如果存在的情况下 那么不做修改 而是将对应的value取出
键如果不存在的情况下 那么就是新增
"""
?
# d.setdefault(‘xxx‘,123)
?
# print(d)  # 键不存在是新增
?
# res = d.setdefault(‘username‘,123)
?
# print(d)  # {‘username‘: ‘jason‘, ‘password‘: 123}
?
# print(res)  # jason
?
# 快速构造字典
?
# res = {}.fromkeys([‘k1‘,‘k2‘,‘k3‘],[])
?
# # print(res)  # {‘k1‘: [], ‘k2‘: [], ‘k3‘: []}
?
# res.get(‘k1‘).append(123)
?
# print(res)
?
"""
A
{‘k1‘: [123], ‘k2‘: [], ‘k3‘: []}
B
{‘k1‘: [123], ‘k2‘: [123], ‘k3‘: [123]}
C
报错
D
我TMD的也不知道
"""
?
# 弹出
?
# res = d.pop(‘username‘)  # 将括号内指定的key对应的value弹出
?
# print(d,res)  # jason
?
# res1 = d.popitem()  # 将弹出的键值对组织成元组的形式返回出去
?
# print(d,res1)  # {‘username‘: ‘jason‘} (‘password‘, 123)
?
?
# 字典方法三剑客
?
# print(d.keys())  # 获取字典所有的key
?
# print(d.values())  # 获取字典所有的value
?
# print(d.items())  # 获取字典所有的key和value组织成小元组
?
"""
可以直接只看里面的数据结构
dict_keys([‘username‘, ‘password‘])
dict_values([‘jason‘, 123])
dict_items([(‘username‘, ‘jason‘), (‘password‘, 123)])
"""
?
# for key in d.keys():
?
#     print(key)
?
# for value in d.values():
?
#     print(value)
?
# for item in d.items():
?
#     print(item)
?
# for k, v in d.items():
?
#     print(k,v)
?
# 清空
?
# d.clear()
?
# print(d)
?
# __class__  # 双下class
?
# s = {1,2,3,4,5,6,7,8}
?
# print(type(s))
?
# s1 = {}
?
# d1 = {}
?
# print(type(s1),type(d1))  # <class ‘dict‘> <class ‘dict‘>
?
# # 定义空集合一定要用set关键字
?
# ss = set()
?
# print(ss,type(ss))  # set() <class ‘set‘>
?
?
# s = {1,1,1,2,3,3,4,3,2,3,4,6,5,3,}
?
# print(s)
?
# 类型转换
?
# s1 = set(‘egon is o DSB‘)
?
# print(s1)
?
# s2 = set([1,2,3,4,5,6,7,7,7,7,7])
?
# print(s2)
?
# s3 = set({‘username‘:‘jason‘,‘password‘:123})
?
# print(s3)  # {‘password‘, ‘username‘}
?
l = [4,3,2,3,4,6,7,8,1,2,3]
?
# # 先转成集合
?
# s = set(l)
?
# # 再转成列表
?
# l1 = list(s)
?
# print(l1)
?
# new_l = []
?
# for i in l:
?
#     if i not in new_l:
?
#         new_l.append(i)
?
# print(new_l)
?
?
# 用户1的好友列表
?
friends1 = {‘jason‘,‘tank‘,‘tony‘,‘jerry‘}
?
# 用户2的好友列表
?
friends2 = {‘jason‘,‘tony‘,‘owen‘,‘oscar‘}
?
# 1 求两个用户的共同好友  交集
?
# res = friends1 & friends2
?
# print(res)  # {‘jason‘, ‘tony‘}
?
# 2 求两个用户所有的好友
?
# res = friends1 | friends2
?
# print(res)  # {‘jerry‘, ‘jason‘, ‘oscar‘, ‘tony‘, ‘tank‘, ‘owen‘}
?
# 3 求用户1独有的好友
?
# res1 = friends1 - friends2
?
# res2 = friends2 - friends1
?
# print(res1,res2)  # {‘jerry‘, ‘tank‘} {‘owen‘, ‘oscar‘}
?
# 4 求两个用户各自独有的好友            对称差集
?
# res = friends1 ^ friends2
?
# print(res)  # {‘owen‘, ‘jerry‘, ‘tank‘, ‘oscar‘}
?
# 5 子集 父集
?
s1 = {12,3,4,5,6}
s2 = {12,6}
print(s1 > s2)  # s1是否是s2的父集
print(s2 < s1)  # s2是否是s1的子集

Python数据类型之基础记。。。

原文：https://www.cnblogs.com/kylin5201314/p/13540401.html