Python的数据类型
标准数据类型
Python3 中有六个标准的数据类型：
- Number（数字）分别包括：
- int、
- float
- bool
- complex（复数）
- String（字符串）
- List（列表）
- Tuple（元组）
- Set（集合）
- Dictionary（字典）
string、list 和 tuple 都属于 sequence（序列）
Python3 的六个标准数据类型中：
- 不可变数据（3 个）：Number、String、Tuple；
- 可变数据（3 个）：List、Dictionary、Set。
# 各类型的定义格式 deposit = 0 salary = 23.55 name = 'xiyang' house = ['天津','河北'] family = ('老妈','老爸','老公','老弟') # 不可变 job = {'work':'软件测试','time':'早9晚6'} age = set('18') # 不可重复 print(type(deposit),type(salary),type(name),type(house),type(family),type(job),type(age)) # <class 'int'> <class 'float'> <class 'str'> <class 'list'> <class 'tuple'> <class 'dict'> <class 'set'> #追加格式 house.append('北京') job.setdefault('price',22.33) age.add(20) print(house,job,age)
int（整型）
简介：
通常被称为整型或整数，是正或负整数，不带小数点。python3中整型是没有限制大小的，可以当做Long类型使用，所有python3中没有Long类型
语法：
age = 18 num = -22
a,b,c = 0,1,2# 一次给多个变量赋值 print(age) print(num)
print(a,b,c)
float（浮点型）
简介：
浮点类型由整数部分与小数部分组成，浮点型也可以使用科学计数法表示（2.5e2 = 2.5 *10次方 = 250 ），浮点型也就是带有小数点的数，其精度和机器有关。
语法：
score = 82.342 num = -022.1 print(score) print(num)
complex（复数）
简介：
Python还支持复数，复数由实数部分和虚数部分构成，可以用 a + bj,或者 complex(a,b) 表示， 复数的实部 a 和虚部 b 都是浮点型。
语法：
pass
boole（布尔类型）
简介：
在 Python2 中是没有布尔型的，它用数字 0 表示 False，用 1 表示 True。到 Python3 中，把 True 和 False 定义成关键字了，但它们的值还是 1 和 0，它们可以和数字相加。
和其他编程语言一样，Python布尔类型也是用于逻辑运算，有两个值：True（真）和False（假）
语法：
age = 18 print(age > 19) print(age < 19) #>>>False #>>>True
string（字符串类型）
简介：
字符串是 Python 中最常用的数据类型。我们可以使用引号( '' 或 "" )来创建字符串。
Python中的字符串有两种数据类型，分别是str类型和unicode类型，str类型采用的ASCII编码，无法表示中文，unicode类型采用unicode编码，能够表示任意字符，包括中文和其他语言。
创建字符串很简单，只要为变量分配一个值即可。
实例：
字符串定义
var1='xiyang' addr = '北京'
字符串更新
var2='Hello xiyang'
# 截取字符串的一部分并与其他字段拼接
print('已更新的字符串：',var2[:6]+'python')
print('已更新的字符串：','Hi'+var2[-7:])
字符串常用方法：
查找
# Python 不支持单字符类型，单字符在 Python 中也是作为一个字符串使用。 # Python 访问子字符串，可以使用方括号 [] 来截取字符串，字符串的截取的语法格式如下
var1 = 'Hello World!' var2 = "Python" print(var1[0]) # 打印字符串var1中下标为0的元素 print(var2[1:5]) # 打印字符串var2中下标从1-5的元素（前包后不包） print(str.index('x')) # 根据元素查找下标。如果下标不存在，报错ValueError: substring not found。不推荐使用 str = 'Hi xiyang' print(str.find('x')) # 根据元素查找下标。如果下标不存在，返回-1。推荐使用 print(str.count('i')) # 统计字符串中某个出现的次数
去空格
s = ' a bc ' print(s.strip()) # 去掉字符串两边的空格和换行符 print(s.rstrip())# 只去掉右边的空格和换行符 print(s.lstrip()) # 只去掉左边的空格和换行符 print(s.replace('a','A')) # 替换，将前边的替换为后边的 print(s.replace(' ','')) # # 去中间空格，该方法可以替换中间的空格，将空格替换为空
大小写转换
s1 = 'Python' print(s1.upper())# 把所有的字母都变成大写 print(s1.lower())# 把所有的字母都变成小写 print(s1.capitalize())# 把首字符变为大写 print(s1.center(50,'*'))# 设置等长为50，若不足50用指定字符在两边填充
判断字符格式
s2 = 'A!TD22. 3' print(s2.isupper())# 出现的字母，是不是都是大写字母 print(s2.islower())# 出现的字母，是不是都是小写字母 print(s2.isalpha())# 是字母或汉字，返回True print(s3.isalnum())# 只有数字或者字母或汉字会返回True，其他的都返回False
判断是否是整数
s4 = '123' print(s.isdigit())# s = '-1's中不只有整数，还有符号-，所以返回False print(s4.isdigit())# s2 = '0's2中是整数，所以返回True print(s4.zfill(5))# 前面补0，这里设置的5为补0后的总长度（该方法仅支持字符串类型）
判断是否以指定字符开头或结尾。返回布尔值True和False
print(s1.startswith('a')) # 判断开头 print(s1.endswith('.jpg')) # 判断结尾
分割（拆分）字符串 split
str = 'hello \npython \nhi' print(str.split(' ')) # 以空格分隔，包含\n #>>>输出结果：['hello', '\npython', '\nhi'] print(str.split(' ',1)) # 以第一个空格分隔，分隔为两个 #>>>输出结果：['hello', '\npython \nhi'] str = 'my..name..is..xiyang' print(str.split('..'))# 使用..拆分 ['my', 'name', 'is', 'xiyang'] print(str.split('..',-1))# 等价于str.split ['my', 'name', 'is', 'xiyang'] print(str.split('..',0))# 和没拆分一样 ['my..name..is..xiyang'] print(str.split('..',1))# 以第一个..拆分，拆分为两个 ['my', 'name..is..xiyang'] print(str.split('..',2))# 以第一个..拆分，拆分为三个 ['my', 'name', 'is..xiyang'
连接字符串 join（和split效果相反）
str1 = ['my', 'name', 'is', 'xiyang'] print(' '.join(str1)) # 将str1中的list使用空格连接 print('_'.join(str1)) # 将str1中的list使用下划线连接 print(''.join(str1)) # 将str1中的list使用空连接，也就是将连接符都去掉
字符串格式化：%s、%d、%f
# 占位符：%s ，是万能占位符，可以跟字符串、整数、小数。如：'欢迎【%s】登录，今天的日期是:%s' # 占位符：%d ，代表整数占位符。如：'你的年龄是：%d'。如果是%d，后边一定是要跟int类型，因为input接收的都是字符串类型，所以要在input时转换成int类型 # 占位符：%f ，代表小数占位符。如：'你的成绩是：%.2f' 。如果是%f，后边一要跟float类型，float默认保留小数点后6位，如果想保留2位则写为：%.2f，想保留几位就写%.xf # 只有一个变量的写法 for i in range(3): username = input('请输入你的名字：') welcome = '欢迎【%s】登录' % username # welcome2 = '欢迎'+username+'登录'# 简单粗暴的方式，用+号连接，不推荐 print(welcome) age = int(input('请输入你的年龄：')) a1 = '你的年龄是：%d' % age print(a1) score = float(input('请输入你的成绩：')) s1 = '你的成绩是：%.2f' % score print(s1) print('==================开始多个变量的写法===================') # 多个变量的写法 import datetime # 导入datetime包 today = datetime.datetime.today()# 获取当前日期 for i in range(3): username = input('请输入你的名字：') age = int(input('请输入你的年龄：')) score = float(input('请输入你的成绩：')) welcome = '欢迎【%s】登录，今天的日期是：%s，你的年龄是：%d，你的成绩是：%.2f' % (username,today,age,score)# 如果是多个%s，后面就要跟多个变量，多个变量要使用括号括起来 # welcome2 = '欢迎' + username + '登录,'+'今天的日期是：' + str(today)# 字符串拼接的方式，需要是相同类型，所以需要将today转换为字符串格式。用+号连接，不推荐 print(welcome)
字符串格式化：format、format_map
# format方法和format_map方法是做字符串格式化的，用{}占位，区别在于format_map方法传的是字典格式。同%s，两种都是做字符串格式化，用哪个都可以，数据多的时候推荐用该方法 s5 = '今天是{},欢迎{}登录' print(s5.format('2020-04-08','xiyang')) # 举例 s6 = 'insert into stu(id,name,email,phone,addr) value({id},{name},{email},{phone},{addr})' # .format{}方法，直接在可变的值中定义好名字，传值时不需要按顺序传值，也可以正确插入 print(s6.format(phone = '17611111111',name = 'xiyang',id = 1,email = '1366625010@qq.com',addr = '北京市')) # .format_map print(s6.format_map({'phone':'17611111111','name':'xiyang','id':1,'email':'1366625010@qq.com','addr':'北京市'}))
# 演示三种写法（%s、format、format_map）的区别 s6 = 'insert into stu(id,name,email,phone,addr) value({id},{name},{email},{phone},{addr})' id = input('请输入id：') name = input('请输入name：') phone = input('请输入phone：') addr = input('请输入addr：') email = input('请输入email：') # %s方式 print('insert into stu(id,name,email,phone,addr) value(%s,%s,%s,%s,%s)' % (phone,id,addr,name,email)) # format方式 print(s.format(phone=phone,addr=addr,id=id,name=name,email=email)) # format_map方式 print(s.format_map({'phone':phone,'name':name,'id':id,'email':email,'addr':addr})) # 结论：%s的方式，当数据多时，如果顺序传混了，那么存值也就存混了，如id在前方，我传了phone在前方，系统就会把我输入的phone的值，放到id中
list（列表、数组）
简介：
List（列表） 是 Python 中使用最频繁的数据类型。
列表可以完成大多数集合类的数据结构实现。列表中可以放任何数据类型，它支持数字，字符串甚至可以包含列表（所谓嵌套）。
列表是写在方括号 [] 之间、用逗号分隔开的元素列表。
和字符串一样，列表同样可以被索引和截取，列表被截取后返回一个包含所需元素的新列表。
可对列表进行创建、查找、切片、增加、修改、删除、循环和排序操作。
索引值以 0 为开始值，-1 为从末尾的开始位置。
语法格式：
list = [元素1,元素2,元素...] # 字符串类型的需要用引号括起来，数字类型的则不用
实例：
创建
list = [123,1.56,'python','java','!@#']
list = [] # 创建一个空列表
查询
print(list) # 输出完整的列表，即[123, 1.56, 'python','java','!@#'] print(list[0]) # 输出第一个元素，即123 print(list[1:4]) # 输出从第二个元素开始，到第四个元素，即[1.56, 'python', 'java'] print(list[2:]) # 输出从第三个元素（第二个下标）开始的所有元素，即['python','java','!@#'] print(list[:-3]) # 输出倒数第三个元素之前的所有元素，即[123, 1.56] print(list * 2) # 输出两次列表，即[123, 1.56, 'python','java','!@#', 123, 1.56, 'python','java','!@#']
新增
mobile = ['oppo','小米','三星','vivo'] mobile.append('华为') # append方法是在列表的末尾增加一个元素 print(mobile)
mobile.insert(1,'一加') # insert方法是在列表的指定位置增加一个元素 print(mobile)
修改
mobile[1] = '苹果' print(mobile)
删除
mobile = ['oppo','小米','小米','三星','vivo','华为','一加'] mobile.pop(1) # pop是指定下标删除，下标不存在会报错，未指定下标时，默认删除最后一个元素 print(mobile) mobile.remove('vivo') # remove方法是删除第一个值为 x 的元素，元素不存在会报错 print(mobile) mobile = ['oppo','小米','三星','vivo','华为','一加'] # del语句可以通过切片的方式进行移除元素 del mobile[2:4] # 删除第2和第3个元素，即'三星','vivo' print(mobile) del mobile[0] # 删除第一个元素，即'oppo' print(mobile) del mobile[:] # 删除整个列表中的元素 print(mobile) del mobile # 此后，再引用 a 就会报错（直到为它赋与另一个值）
列表常用方法
num = [33,1,3,45.67,99,1093,44,32,67,1] num1 = [9,8,7] print(num.count(1)) # 查找参数出现的次数 print(num.index(44)) # 查找元素的下标
print(len(num)) # 打印num数组中的元素个数 # print(num.clear()) # 清空列表，相当于del a[:] num.extend(num1) # 合并列表，合并后产生一个新列表
num2 = num + num1 # 用加号拼接列表，也可达到合并列表的目的
num.sort() # 排序，默认升序 num.sort(reverse=True) # 倒序排序 num.reverse() # 反转，即把最后一个展示在前面，前面的展示到最后，和排序是有区别的 print(num) # 您可能已经注意到，方法sort、reverse只修改列表，没有返回值，它们返回的默认 None。这是Python中所有可变数据结构的设计原则。所以如果直接使用print(num.sort)输出的是None
多维数组 创建 & 取值
array = ['1','2','3','4',['a','b','c','d']] # 二维数组 array1 = [1,2,3,4,['A','B','C','D',['!','@','#','$']]] # 三维数组 array2 = [1,2,3,['A','B','C','D','E',['!','@','#','$',['2',3,'P','T']]]] # 四维数组
print(array1[4][4][1])# 取值@ print(array2[3][5][4][2])# 取值P
嵌套列表
arr1 = ['a','b','c','d'] arr2 = [1,2,3,4] arr3 = ['你','好'] arr = [arr1,arr2,arr3] print(arr) # >>> [['a', 'b', 'c', 'd'], [1, 2, 3, 4], ['你', '好']]
实现堆栈--后进先出（可用列表形式轻松实现）
# 使用列表的append()和pop()两个函数组合即可轻松实现 stack = [1,2,3] stack.append(4) print(stack) stack.pop() print(stack)
实现队列--先进先出（使用列表形式实现队列很慢，因为所有其他元素都必须移动一位，这里不推荐使用），实现队列最好用 collections.deque，可以快速从两端添加或删除元素
from collections import deque queue = deque(["Eric", "John", "Michael"]) queue.append("Terry") # 在列表的最后方增加元素 print(queue) queue.popleft() # 在列表的最前方删除元素 print(queue)
tuple（元组）
简介：
元组与列表类似，不同之处在于元组的元素不能修改，所以不支持append、inster、pop等方法。
元组写在小括号 () 里，元素之间用逗号隔开。
元组中的元素类型也可以不相同。
注意构造包含 0 或 1 个元素的元组的特殊语法规则。
实例：
元组创建 & 查找
tuple = (1,1,2.53,'!@#','oppo','小米','三星','vivo') tuple1 = ('苹果','华为') tuple2 = () # 创建一个空元组
tuple3 = (20,) # 一个元素，需要在元素后面添加逗号
print(tuple) # 打印tuple元组 print(tuple[2]) # 打印出元组中下标为2的元素 print(tuple[:4]) # 打印元组中下标为4之前的所有元素（不包含下标4） print(tuple[2:]) # 打印元组中从下标2开始，之后的所有元素（包含下标2） print(tuple[3:6]) # 打印元组中从下标3开始（包含下标3），到下标6之前的元素（不包含下标6） print(tuple * 2) # 输出两次元组 print(tuple + tuple1) # 合并元组，元组不支持extend的方式合并 print(tuple.index('oppo')) # 查找某个元素的下标 print(tuple.count(1)) # 统计某个元素出现的次数 print(len(tuple)) # 打印出元组中元素的个数
多维元组 / 元组嵌套
tuple = (1,1,2.53,'!@#','oppo','小米','三星','vivo',('苹果','华为'),['锤子','一加']) print(tuple[-3:])
# 虽然tuple的元素不可改变，但它可以包含可变的对象，比如list列表。
dictionary（字典）
简介：
字典是一种键值对的集合，是Python中除列表以外，另一个非常有用和灵活的内置数据类型。
列表是有序的对象集合，字典是无序的对象集合。两者之间的区别在于：字典当中的元素是通过键来存取的，而不是通过偏移存取。
字典是一种映射类型，字典用 { } 标识，它是一个无序的 键(key) : 值(value) 的集合。
字典的key必须使用不可变类型。
在同一个字典中，键(key)必须是唯一的。
实例：
创建
info1 = {} # 创建一个空字典
info2 = {
'moble':'iphone 12 pro max'
}
info = {
'name': '溪洋',
'num':13412345678,
'qq':1361111,
'email':'1361111@qq.com',
'addr':'北京'
} # 创建一个有内容的字典
查询
print(info['name']) # 输出key为name的value,取不存在的key，会报错。不推荐使用 print(info.get('addr')) # 输出key为name的value,取不存在的key，返回None。推荐使用
print(info.keys()) # 输出字典中所有的key，注意字典是无序的 print(info.values()) # 输出字典中所有的value，注意字典是无序的 info.update(info2) # 合并字典 print(info) # 输出完整的字典
新增
info.setdefault('sex','女') # 该写法如果新增的key在原列表中存在，对其不做处理 info ['age'] = 18 # 该写法如果新增的key在原列表中存在，会对原有值进行修改
修改
info ['num'] = '133' # 通过key修改value
删除
info.pop('email') # 删除指定key，和del的两种写法没区别 del info['num'] # 删除指定key，和pop的两种写法没区别 info.popitem() # 随机删除指定key，该功能基本用不到 # info.clear() # 清空字典 print(info)
常用方法
info = { 'name': '溪洋', 'num':13412345678, 'qq':1361111, 'email':'1361111@qq.com', 'addr':'北京' } # 创建一个有内容的字典 print(len(info)) # 计算字典元素个数，即键的总数。 print(type(info)) # 返回输入的变量类型，如果变量是字典就返回字典类型。 print('name' in info) # 判断键。如果键在字典dict里返回true，否则返回false
字典嵌套
info = { 'xiyang':{ 'house':['北京','上海','成都','江苏'], 'car':{ 'china':['比亚迪','长安','红旗'], 'japan':['丰田','马自达','雷克萨斯'], 'Genmany':{ '奔驰':2, '宝马':3, '大众':5 } } } }
# 溪洋又买了一辆宝马 stu_info['xiyang']['car']['Genmany']['宝马']+=1 # a+=1等同于a=a+1。包括-= /= *=同理，如a-=2，就是a=a-2 print(stu_info) # 溪洋把比亚迪扔掉了 stu_info['xiyang']['car']['china'].remove('比亚迪')# 按照字典层级去找 print(stu_info)
字典循环
# 第一种效率快一些，第二种慢一些，数据多的话用第一种
accounts = { 'name':'xiyang', 'age':18, 'job':'软件测试' } accounts1 = { 'sex':'女' } accounts2 = { 'email':'136000',
'sex':'女'
# 方法一：直接循环字典 for k in accounts: # print('%s ==> %s' %(k,accounts[k]))
# 方法二：使用items()函数 for k,v in accounts.items(): print('%s ==> %s' % (k,v))
# enumerate()函数：同时取位置索引和对应的值 for i, v in enumerate(accounts): print(i, v) # >>>0 name 1 age 2 job # zip() 函数：同时循环两个或多个序列 for a,b,c in zip(accounts,accounts1,accounts2): print(accounts,accounts1,accounts2) # >>>{'name': 'xiyang', 'age': 18, 'job': '软件测试'} {'sex': '女'} {'email': '136000', 'sex': '女'} # reversed()函数：逆向循环 for i in reversed(accounts): print(i,accounts[i]) # sorted()按指定顺序循环序列 basket = ['apple', 'orange', 'apple', 'pear', 'orange', 'banana'] for i in sorted(basket): print(i) # set()去除序列中重复的元素 basket = ['apple', 'orange', 'apple', 'pear', 'orange', 'banana'] for f in sorted(set(basket)): print(f)
json & pickle
简介
# 在python中，有专门处理json格式的模块--json 和 pickle模块 # json 模块提供了四个方法： dumps、dump、loads、load # pickle 模块也提供了四个功能：dumps、dump、loads、load # json的数据格式其实就是python里面的字典格式，里面可以包含方括号括起来的数组，也就是python里面的列表。 # json的数据必须使用双引号
# json格式通常用于现代应用程序的数据交换
实例
import json data = { "error_code":0, "stu_info":[ { "id":300, "name":"怡宝", "sex":"男", "age":18, "addr":"北京市海淀区" }, { "id": 301, "name": "农夫山泉", "sex": "女", "age": 18, "addr": "北京市朝阳区" }, { "id": 302, "name": "百岁山", "sex": "男", "age": 18, "addr": "北京市昌平区" } ] }
# json模块把字典转成json字符串的方法--dumps with open('abc.txt','w',encoding='utf-8') as fw: s = json.dumps(data,ensure_ascii=False, indent=4) fw.write(s) print(s) # 参数解释： # data，需要转换为json格式的字符串 # ensure_ascii=False，解决中文问题，若为True则输出的格式为Unicode # indent=4，代表缩进，4个空格
# json模块把字典转成json字符串的方法--dump with open('abc.txt','w',encoding='utf-8') as fw: s = json.dump(data,fw,ensure_ascii=False, indent=4) print(s) # 参数解释： # data，需要转换为json格式的字符串（字典） # fw, 需要打开的文件名 # ensure_ascii=False，解决中文问题，若为True则输出的格式为Unicode # indent=4，代表缩进，4个空格
# dumps方法和dump方法的区别： # dump比dumps方法多传一个文件名，dump就不需要手工的write一次了，这个方法会自动write。
# json模块把字符串转成字典的方法--loads with open('abc.txt', encoding='utf-8') as fr: # json字符串要在文件中存在才可以 result = fr.read() print('result,刚从文件里面读出来的',result,type(result)) dic = json.loads(result) # loads代表字符串转成字典 print('dic,转换完之后的', dic, type(dic))
# json模块把字符串转成字典的方法--loads with open('abc.txt', encoding='utf-8') as fr: # json字符串要在文件中存在才可以 result = json.load(fr) print('result',type(result)) print(result)
# loads方法和load方法的区别： # load比loads方法多传一个文件名，load方法就不需要手工的read一次了，这个方法会自动read，相对来说load方法更简单一些
set（集合）
简介：
集合是一个无序的、不重复的数据组合，它的主要作用有两个，分别是：进行成员关系测试和删除重复元素。
集合是由一个或数个形态各异的大小整体组成的，构成集合的事物或对象称作元素或是成员。
可以使用大括号 { } 或者 set() 函数创建集合，注意：创建一个空集合必须用 set() 而不是 { }，因为 { } 是用来创建一个空字典。
集合天生可以去重，并且是无序的（就是不能通过下标来取值）。但是可以通过循环去取值
实例：
定义&取值
s = set() # 定义一个空集合
s1 = [1,1,2,3,4,3] print(set(s1)) # 输出的结果是{1, 2, 3, 4} #通过循环取值 for i in s1: print(i) # 输出的结果是1 1 2 3 4 3
添加元素 add()和update()
s = set() # 定义一个空集合 # add()方法添加元素：参数可以是整数，小数，字符串，元组 s.add(1) s.add(2.32) s.add('d') s.add((7,)) print(s)
# update()方法添加：参数可以是列表，元组，集合，字典，字符串 s.update([2]) s.update((5,)) s.update({3}) s.update({'name':'xiyang'}) # 只能将key添加进去'name' s.update('2')
print(s)
# 使用add()和update()两种方法重复添加值 s2 = {8,9,10,11,'a'} # 如果添加重复的元素，比如s2.add(8)、s2.update('a')，是不会加进去的。因为集合本身就是不能重复的 s2.add(8) s2.update('a') s2.update(['a','b']) print(s2) # >>>{'b', 8, 9, 10, 11, 'a'}只添加进去了b，因为a和8原本的集合中已经存在了
删除
s.remove(1) # 删除元素
s.discard(5) # 删除集合中指定的元素 print(s.pop()) # 随机删除一个元素
print(s)
其他
print(len(s2))# 打印集合中元素的长度（去重后的长度）
print(s.copy()) # 拷贝一个集合
交集、并集、差集、对称差集
language1 = ['c','c++','java','python'] language2 = ['python','js','css','html'] lan1_set = set(language1) lan2_set = set(language2) # 取交集的两种写法。取多个集合里边都有的 print(lan1_set.intersection(lan2_set)) print(lan1_set & lan2_set) # >>> {'python'} # 取并集的两种写法。把多个集合合并到一起，在去重 print(lan1_set.union((lan2_set))) print(lan1_set | lan2_set) # >>> {'c', 'js', 'java', 'html', 'c++', 'python', 'css'} # 取差集的两种写法。取出在a集合里边有，在b集合里边没有的 print(lan1_set.difference(lan2_set)) print(lan1_set - lan2_set) # >>> {'java', 'c', 'c++'} # 取对称差集的两种写法。把多个集合中都有的元素删除，在取出（两个集合的并集减去它们的交集） print(lan1_set.symmetric_difference(lan2_set)) print(lan1_set ^ lan2_set) # >>> {'c', 'js', 'java', 'html', 'c++', 'css'}
判断
language1 = ['c','c++','java','python'] language2 = ['python','js','css','html'] lan1_set = set(language1) lan2_set = set(language2) print(lan1_set.isdisjoint(lan2_set)) # 判断两个集合是否包含相同的元素，如果有返回 False，如果没有返回 True。 print(lan1_set.issubset(lan2_set)) # 判断指定集合是否为该方法参数集合的子集。如果有返回 True，如果没有返回 False。 print(lan1_set.issuperset(lan2_set)) # 判断该方法的参数集合是否为指定集合的子集。如果有返回 True，如果没有返回 False。
学而时习之不亦说乎！
