zoukankan      html  css  js  c++  java
  • 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 
    python 
    hi'
    
    print(str.split(' ')) # 以空格分隔,包含
    
    #>>>输出结果:['hello', '
    python', '
    hi']
    
    print(str.split(' ',1)) # 以第一个空格分隔,分隔为两个
    #>>>输出结果:['hello', '
    python 
    hi']
    
    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.pop(1) # pop和del方法是指定下标删除,下标不存在会报错
    print(mobile)
    
    del mobile[2]
    print(mobile)
    
    mobile.remove('小米') # remove方法是指定元素删除,元素不存在会报错
    print(mobile)

    列表常用方法

    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()) # 清空列表 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], ['你', '好']]

    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])

    json & pickle

    简介

    # 在python中,有专门处理json格式的模块--json 和 pickle模块
    # json   模块提供了四个方法: dumps、dump、loads、load
    # pickle 模块也提供了四个功能:dumps、dump、loads、load
    
    # json的数据格式其实就是python里面的字典格式,里面可以包含方括号括起来的数组,也就是python里面的列表。
    # 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。
    学而时习之不亦说乎!
  • 相关阅读:
    使用ueditor实现多图片上传案例——Servlet层(UploadServlet)
    使用ueditor实现多图片上传案例——截取字符串层Util(SubString_text)
    [转载]oracle删除数据后的恢复
    [转载]oracle删除数据后的恢复
    为什么在定义hashcode时要使用31这个数呢?
    为什么在定义hashcode时要使用31这个数呢?
    [转载]hashCode和equals
    [转载]hashCode和equals
    Oracle HINT的用法
    Oracle HINT的用法
  • 原文地址:https://www.cnblogs.com/wxinyu/p/14699942.html
Copyright © 2011-2022 走看看