精华内容
下载资源
问答
  • 列表元组字典集合的比较
    2020-03-10 16:59:03

    python常用内置数据类型的总结:
    1.形式:
    列表list:[1,2,3] [a,b,c] [‘myss’,{2},(1,3),[‘c’,2],{65:‘A’}]
    【所有元素放在一对方括号中,元素之间使用逗号分隔,其中的元素可以是任意类型】
    元组tuple:(1,2,3) (1,)
    【所有元素放在一对圆括号中,元素之间使用逗号分隔,元组中只有一个元素时后面的逗号不能省略】
    字典dict:{‘a’:97,‘b’:98,‘c’:99,‘d’:100} {1:‘a’:2:‘b’}
    【所有元素放在一对大括号中,元素之间使用逗号分隔,元素形式为“键:值”,其中“键”不允许重复并且必须为不可变类型,“值”可以是任意类型的数据】
    集合set:{‘a’,‘b’,‘c’}
    【所有元素放在一对大括号中,元素之间使用逗号分隔,元素不允许重复且必须为不可变类型;集合中只能包含数字、字符串、元组等不可变类型的数据,而不能包含列表、字典、集合等可变类型的数据,包含列表等可变类型数据的元组也不能作为集合的元素。集合不支持使用下标直接访问特定位置上的元素,也不支持使用random中的choice()函数从集合中随机选取元素,但支持使用random模块中的sample()函数随机选取部分元素。】
    字符串str:‘abcd’ “abcd” ‘’‘a"bc"d’’’
    【使用单引号、双引号、三引号作为定界符,不同定界符之间可以互相嵌套;前面加字母r或R表示原始字符串,任何字符都不进行转义】
    2.功能和用法
    (1)可用下标0寻找列表或元组的第一个元素;而字典不可下标,应用“键”寻找对应的值。
    (2)列表,字典,集合可变;元组,字符串不可变。所以不可以修改字符串里的内容,也不能删除其中的字符。所以元组不存在追加插入删除等函数,且元组可使代码更安全。
    (3)元组可以作为字典的键,也可作为集合的元素;列表均不可。
    (4)字符串,列表和元组的元素是有顺序的;集合和字典内的元素则忽略顺序。
    (5)元组可由tuple()转换,列表用list()。
    (6)字符串前加r或者R表示原始字符串,避免因为特殊字符进行转义。
    (7){}:空字典
    []:空列表
    ():空元组
    (8)创建方法除了可以直接创建外:
    列表:x=list()
    元组:x=tuple()
    字典:x=dict()
    集合:x=set()
    字符串:x=str()
    (9)encode()函数可以把字符串转化为字节串,decode()解码成为字符串

    更多相关内容
  • 很全面的讲解了Python列表 字典 文件操作等知识 很详细很有范 值得下载拥有
  • 列表list定义符号:[]创建:[]直接创建 , list()可变性:可变是否有序:有序元素是否重复:可以重复切片:支持切片索引:支持索引访问:索引访问删除:del()list.remove(value)list.pop()修改插入:list[]=append()...

    列表list

    定义符号:[]

    创建:[]直接创建 , list()

    可变性:可变

    是否有序:有序

    元素是否重复:可以重复

    切片:支持切片

    索引:支持索引

    访问:索引访问

    删除:

    del()

    list.remove(value)

    list.pop()

    修改插入:

    list[]=

    append()

    insert()

    extend()

    +

    遍历:for循环遍历

    for i in list:

    +或*: 支持

    元组tuple

    定义符号:()

    创建:() 直接创建 , tuple()

    可变性:不可变

    是否有序:有序

    元素是否重复:可以重复

    切片:支持切片

    索引:支持索引

    访问:索引访问

    删除:

    del()

    修改插入:不可修改

    遍历:for循环遍历

    for i in tuple:

    +或*: 支持

    字典dict

    定义符号: {key:value}

    创建: dict{key:value} {}直接创建

    可变性:可变

    是否有序:无序

    元素是否重复:键不可以重复

    切片:不支持切片

    索引:不支持索引

    访问:

    键访问

    get()访问

    删除:

    del()

    修改插入:

    dict[key]=value

    遍历:for循环遍历

    for key,value in dict.items:

    key_list=list(dict2.keys()) #输出字典中所有的key值

    print(key_list)

    value_list=list(dict2.values()) #输出字典中所有的value值

    print(value_list)

    items_list=list(dict2.items()) #输出以元组方式的键对值

    +或*: 不支持

    集合set

    定义符号:{}

    创建:{}直接创建 set()

    可变性:可变

    是否有序: 无序

    元素是否重复:不可以重复

    切片:不支持切片

    索引:不支持索引

    删除:

    del()

    set.pop()

    set.remove()

    set.clear()

    修改插入:

    set.add()

    遍历:

    for循环遍历 for i in set:

    +或*: 不支持

    其他:交集& 并集|

    set1={1,2,3,4,5}

    set2={2,3,4}

    ret=set1&set2

    print(ret) #输出{2,3,4}

    ret1=set1|set2

    print(ret1) #输出{1,2,3,4,5}

    去重:

    set1={11,11,22,22,33,44}

    ret=set(set1)

    print(ret) #输出结果{22,11,33,44}

    本文地址:https://blog.csdn.net/weixin_44024993/article/details/107364819

    如您对本文有疑问或者有任何想说的,请点击进行留言回复,万千网友为您解惑!

    展开全文
  • 列表字典元组集合的特点
  • Python语法——列表元组集合字典 综述: 列表(List) [ ] 是一种有序和可更改 的集合。允许重复的成员。 元组(Tuple) ( ) 是一种有序且不可更改的集合。允许重复的成员。 集合(Set) { } 是一个无序和无...

    Python语法——列表、元组、集合、字典

    综述:

    列表(List)    [         ]
    是一种有序和可更改 的集合。允许重复的成员。
    元组(Tuple) (        )
    是一种有序且不可更改的集合。允许重复的成员。
    集合(Set)     {        }
    是一个无序和无索引的集合。没有重复的成员。
    词典(Dictionary){"key":"value"......}
    是一个无序,有索引和可变的集合。没有重复的成员。
    

    一、列表的相关操作

    #创建列表
    thislist = ["apple", "banana", "cherry", "orange", "kiwi", "melon", "mango"]
    print(thislist)
    
    #访问
    负索引表示从末尾开始,0 表示第一个项目,-1 表示倒数第一个项目,依此类推。
    print(thislist[-1])  #结果是 mango
    
    #len()方法   获取列表有多少项  print(len(thislist))
    #count()方法 返回具有指定值的元素数量 变量=列表.count("元素")
    #reverse()方法 反转元素的排序顺序 列表.reverse()
    #sort()方法  默认情况下,对列表进行升序排序,还可以让函数来决定排序标准
    list.sort(reverse=True/False, key=函数方法)
    实例:
            def myFunc(e):
              return len(e)
            cars = ['Porsche', 'Audi', 'BMW', 'Volvo']
            cars.sort(key=myFunc)
            print(cars)
    count()函数:统计了列表指定元素的个数
    实例:
            >>> a = 'banana pie banana'
            >>> a.count('a',2)
            5
    #列表的增
    1. append()方法 将项目添加到列表的末尾 方法:列表.append("元素")
    2. insert()方法 在指定的索引出添加项目 方法:列表.insert(索引位置,"元素")
    3. extend()方法 指定的列表元素(或任何可迭代的元素)添加到当前列表的末尾 方法:目标列表.extende(后接的列表)
    #列表的删
    1. remove()方法 删除指定的元素 方法:列表.remove("元素") 删除列表第一个匹配项
    2. pop()方法    删除指定的索引(如果未指定索引,则删除最后一项)方法:列表.pop(index)
    3. del()方法    删除指定的索引 方法:del thinlist[index]
                    删除完整的列表 方法:del 列表名
    4. clear()方法  清空列表内容,保留列表格式 方法:列表名.clear()
    #列表的改
     直接覆盖
    #列表的查
    if "apple" in thislist:
      print("Yes, 'apple' is in the fruits list")
    

    二、元组的相关操作

    #创建元组
    thistuple = ("apple", "banana", "cherry")
    print(thistuple)
    
    #访问
    返回第三、第四、第五个项目
    thistuple = ("apple", "banana", "cherry", "orange", "kiwi", "melon", "mango")
    print(thistuple[2:5])  左闭右开
    print(thistuple[-4:-1]) 左开右闭
    #元组的增
    #元组的删
    #元组的改
        注意:
            创建元组后,您将无法更改其值。元组是不可变的,或者也称为恒定的。
            但是有一种解决方法。您可以将元组转换为列表,更改列表,然后将列表转换回元组。
        实例:
            x = ("apple", "banana", "cherry")
            y = list(x)
            y[1] = "kiwi"
            x = tuple(y)
            print(x)
    #合并两个元组
    实例:
        tuple1 = ("a", "b" , "c")
        tuple2 = (1, 2, 3)
        tuple3 = tuple1 + tuple2
        print(tuple3)
    

    三、集合的相关操作

    #创建集合
    thisset = {"apple", "banana", "cherry"}
    print(thisset)
    #访问
        无法通过引用索引来访问 set 中的项目,因为 set 是无序的,项目没有索引。
        但是您可以使用 for 循环遍历 set 项目,或者使用 in 关键字查询集合中是否存在指定值。
    #集合的增
    1. add() 要将一个项添加到集合 方法:集合.add("元素")
    2. update() 要向集合中添加多个项目 方法:集合.update(["orange", "mango", "grapes"])
    实例:
        set1 = {"a", "b" , "c"}
        set2 = {1, 2, 3}
        set1.update(set2)
        print(set1)
    3. union() 返回一个新集合,其中包含两个集合中的所有项目 
    实例:
        set1 = {"a", "b" , "c"}
        set2 = {1, 2, 3}
        set3 = set1.union(set2)
        print(set3)
    '''注意:union() 和 update() 都将排除任何重复项。'''
    
    #集合的删
    1. remove() 与列表一致            如果要删除的项目不存在 将引发错误
    2. discard() 集合.discard("元素") 如果要删除的项目不存在 不会引发错误
    3. pop() 与列表一致 但是注意:     集合是没有索引的,因此在使用该方法时,您不会知道删除的是哪个项目
    4. del() 与列表一致
    #集合的改
    #集合的查
     1.for 循环遍历
     2.if xx in xx:
    

    四、字典的相关操作

    #字典的创建
    thisdict =	{
      "brand": "Porsche",
      "model": "911",
      "year": 1963
    }
    print(thisdict)
    #访问
        通过在方括号内引用其键名来访问字典的项目
        x = thisdict["model"]
        #打印所有键名
        for x in thisdict:
        	print(x)
        #打印所有值
        for x in thisdict:
      		print(thisdict[x])
        #打印键和值
        for x, y in thisdict.items():
      		print(x, y)
    #字典的改
        直接覆盖
        thisdict["year"] = 2019
    #字典的删
    1. pop() 删除键和值 字典.pop("key")
    2. popitem() 删除最后的键和值 字典.popitem()
    3. del 关键字删除具有指定键名的项目 也可以完全删除字典
    4. clear() 关键字清空字典
    
    展开全文
  • 列表元组、字符串属于序列,字典属于映射,集合不属于2者其中之一。 在序列中,每个元素都有编号。 1、元组(tuple) 与列表类似,但元组是不可变的,可简单将其看作是不可变的列表元组常用于保存不可修改的内容...
  • 本文详细归纳整理了Python中列表字典元组集合数据结构。分享给大家供大家参考。具体分析如下: 列表:复制代码 代码如下:shoplist = [‘apple’, ‘mango’, ‘carrot’, ‘banana’] 字典:复制代码 代码如下...
  • python容器:列表元组字典集合的思维导图
  • python系列之:列表元组集合字典的区别一、列表元组集合字典的区别二、for循环遍历列表元组字典集合1.遍历列表2.遍历元组3.遍历字典4.遍历集合三、列表元组集合字典相互转换1.列表元组转化...

    一、列表、元组、集合、字典的区别

    • 列表:长度可变有序的数据存储容器,可以通过下标索引取到相应的数据。
    • 元组:固定长度不可变的顺序容器,访问效率高,适合存储一些常量数据,可以作为字典的键使用。
    • 集合:无序,元素只出现一次,可以自动去重。
    • 字典:长度可变的hash字典容器。存储的方式为键值对,可以通过相应的键获取相应的值。key支持多种类型,key必须是不可变类型且唯一。

    列表和元组的主要区别如下:

    • 列表上可以修改的,而元组不能修改。如果要增添和删除元素,只能用列表。元组被称为只读列表,即数据可以被查询,但不能被修改。若元组一旦被定义,长度和内容都是固定的,不能被修改,即不能对元组进行更新、增加和删除的操作。
    • 列表用’[]'表示,元组用()表示
    • 列表不能作为字典的可以,元组可以
    • 如果元组中仅有一个元素,需要在元素后加上逗号。

    二、for循环遍历列表、元组、字典和集合

    1.遍历列表

    testList = [4,2,3,1,4]
    
    print("遍历list:",end='')
    for items in testList:
        print(items,end=' ')
    

    2.遍历元组

    print()
    print("遍历tuple:",end='')
    testTuple = (5,2,1,3,4)
    for items in testTuple:
        print(items,end=' ')
    

    3.遍历字典

    print()
    print("遍历dict:",end='')
    testDict = {'a':1,'b':2}
    for key,value in testDict.items():
        print(key,value,end=' ')
    

    4.遍历集合

    print()
    print('遍历set:',end='')
    testSet = {12,4,6,5}
    for items in testSet:
        print(items,end=' ')
    

    输出如下所示:

    遍历list:4 2 3 1 4 
    遍历tuple:5 2 1 3 4 
    遍历dict:a 1 b 2 
    遍历set:4 12 5 6
    

    三、列表、元组、集合和字典相互转换

    1.列表元组转化为集合(去重)

    #两个列表转集合,去重
    list1 = [6,7,7,8,8,9]
    set1 = set(list1)
    print(set1)
    

    输出如下所示:

    {8, 9, 6, 7}
    

    2.两个列表转字典

    #两个列表转字典
    list1 = ["key1","key2","key3"]
    list2 = ["1","2","3"]
    dict1 = dict(zip(list1,list2))
    print(dict1)
    

    输出如下所示:

    {'key1': '1', 'key2': '2', 'key3': '3'}
    

    3.嵌套列表转字典

    #嵌套列表转字典
    list3 = [["key1","valu1"],["key2",'value2'],['key3','value3']]
    dict1 = dict(list3)
    print(dict1)
    

    输出如下所示:

    {'key1': 'valu1', 'key2': 'value2', 'key3': 'value3'}
    

    4.列表、元组转字符串

    #列表、元组转字符串
    list1 = ['s','a','b']
    str1 = " ".join(list1)
    print(str1)
    
    tup1 = ('b','t','u')
    str2 = "-".join(tup1)
    print(str2)
    

    输出如下所示:

    s a b
    b-t-u
    

    5.字典转化为字符串

    dic1 = {'a':1,"b":2}
    str1 = str(dic1)
    print(type(str1))
    print(str1)
    

    输出如下所示:

    <class 'str'>
    {'a': 1, 'b': 2}
    

    6.字典key和value互相转换

    #字典key和value互相转换
    
    dic2 = {"a":1,"b":2}
    
    dic3 = {value:key for key,value in dic2.items()}
    print(dic3)
    

    输出如下所示:

    {1: 'a', 2: 'b'}
    

    7.字符串转换为列表

    #字符串转换为列表
    s = 'dstewsg'
    list1 = list(s)
    print(list1)
    

    输出如下所示:

    ['d', 's', 't', 'e', 'w', 's', 'g']
    

    8.字符串转元组

    #字符串转元组
    s = "ugjhaga;w"
    tu1 = tuple(s)
    print(tu1)
    

    输出如下所示:

    ('u', 'g', 'j', 'h', 'a', 'g', 'a', ';', 'w')
    

    9.字符串转集合

    #字符串转集合
    dic2 = eval("{'a':1,'age':2}")
    print(dic2)
    

    输出如下所示:

    {'a': 1, 'age': 2}
    

    10.切分字符串

    #切分字符串
    a = 'a b c'
    a = a.split(' ')
    print(a)
    

    输出如下所示:

    ['a', 'b', 'c']
    

    四、删除一个列表重复元素

    1.使用集合set方式

    #利用set中的元素不可重复性来去重
    elements = ['a','b','e','c','b','d','a','c','f']
    
    e = list(set(elements))
    print(e)
    

    输出如下所示:

    ['d', 'c', 'b', 'a', 'f', 'e']
    

    要保持列表元素的原来顺序,可以利用list类的sort方法

    #利用list的sort方法保持列表原来顺序
    e.sort(key=elements.index)
    print(e)
    

    输出如下所示:

    ['a', 'b', 'e', 'c', 'd', 'f']
    

    2.使用字典的方式,利用字典key的唯一性

    #使用字典的方式
    #利用了字典的键的唯一性
    elements = ['a','b','e','c','b','d','a','c','f']
    e = list({}.fromkeys(elements).keys())
    print(e)
    

    python函数dict.fromkey(seq,[,value])用于创建一个新字典以序列seq中元素做字典的键,value为字典所有键对应的初始值

    #python函数dict.fromkey(seq,[,value])用于创建一个新字典
    #以序列seq中元素做字典的键,value为字典所有键对应的初始值
    seq = ['a','b','c']
    dict1 = dict.fromkeys(seq,[9,4,3])
    print(dict1)
    

    输出如下所示:

    {'a': [9, 4, 3], 'b': [9, 4, 3], 'c': [9, 4, 3]}
    

    3.列表推导的方式

    #方式三:列表推导的方式
    elements = ['a','b','e','c','b','d','a','c','f']
    e = []
    for i in elements:
        if not i in e:
            e.append(i)
    print(e)
    

    以上代码也可以使用列表生成式简写成

    #以上代码也可以使用列表生成式简写成
    elements = ['a','b','e','c','b','d','a','c','f']
    e = []
    [e.append(i) for i in elements if i not in e]
    print(e)
    

    4.reduce函数

    • reduce函数的定义:
    • reduce(function, sequence[, initial]) -> value
    • function参数是一个有两个参数的函数,reduce依次从sequence中取一个元素,和上一次调用function的结果做参数再次调用function。
    #reduce函数
    from functools import reduce
    
    # reduce函数的定义:
    # reduce(function, sequence[, initial]) -> value
    # function参数是一个有两个参数的函数,reduce依次从sequence中取一个元素,和上一次调用function的结果做参数再次调用function。
    
    elements = ['a','b','e','c','b','d','a','c','f']
    print([[]]+elements)  #[[], 'a', 'b', 'e', 'c', 'b', 'd', 'a', 'c', 'f']
    v = reduce(lambda x,y:x if y in x else x+[y],[[]]+elements)
    print(v)
    

    输出如下所示:

    [[], 'a', 'b', 'e', 'c', 'b', 'd', 'a', 'c', 'f']
    ['a', 'b', 'e', 'c', 'd', 'f']
    

    五、求两个列表的交集、差集或并集

    1.for循环

    a = [1,2,3,4,5]
    b = [2,4,5,6,7]
    
    #交集
    result = [i for i in a if i in b]
    print('a与b的交集:',result)
    
    #差集,在a中但不在b中
    
    result = [i for i in a if i not in b]
    print('a与b的差集:',result)
    
    #并集
    result = a
    for r in b:
        if r not in result:
            result.append(r)
    print('a与b的并集:',result)
    

    输出如下所示:

    a与b的交集: [2, 4, 5]
    a与b的差集: [1, 3]
    a与b的并集: [1, 2, 3, 4, 5, 6, 7]
    

    2.用set操作

    #用set操作
    a = [1,2,3,4,5]
    b = [2,4,5,6,7]
    
    #交集
    result = list(set(a).intersection(set(b)))
    print('a与b的交集:',result)
    
    #差集 在a中但不在b中
    result = list(set(a).difference(set(b)))
    print("a与b的差集:",result)
    
    #并集
    result = list(set(a).union(set(b)))
    print('a与b的交集:',result)
    

    输出如下所示:

    a与b的交集: [2, 4, 5]
    a与b的差集: [1, 3]
    a与b的交集: [1, 2, 3, 4, 5, 6, 7]
    

    六、反序地迭代一个序列

    对序列反序,可以利用内置函数reversed()或range()来实现,也可以用扩展切片[::-1]的形式实现。序列是列表,还可以使用列表自带的reverse()方法。

    1. reversed()是python内置函数,参数可以是字符串、列表或元组等序列

    2. 利用range()方法生成序列宕反序索引,然后从最后的元素遍历到开始的元素,就可以反序输出序列的元素。range(start,stop[,step])方法的参数说明

      • start:计数从start开始,默认是从0开始
      • end:计数到end结束,但不包括end
      • step:步长,默认为1
    3. sea[::-1]扩展切片方法是利用粱序列宕切片操作,切片是序列的高级特性。seq[::-1]表示反向获取seq中的所有元素,并且每次取一个。-1表示从序列宕最后一个元素反向遍历获取。

    4. 如果是列表序列,还可以直接用列表的reverse()方法

    1.reversed()内置的函数方法

    seq = "Hello World"
    
    #reversed()内置的函数方法
    for s in reversed(seq):
        print(s,end='')
    
    #输出换行
    print()
    

    输出如下所示:

    dlroW olleH
    

    2.range()函数方法

    #range()函数方法
    for i in range(len(seq)-1,-1,-1):
        s = seq[i]
        print(s,end='')
    #输出换行
    print()
    

    3.[::-1]扩展切片方法

    #[::-1]扩展切片方法
    for s in seq[::-1]:
        print(s,end='')
    #输出换行
    print()
    

    4.list自带的reverse()方法

    #list自带的reverse()方法
    seq = [1,2,3,4,5,6]
    seq.reverse()
    for s in seq:
        print(s,end='')
    print()
    

    输出如下所示:

    654321
    

    七、列表的sort方法和sorted方法

    • sort是列表方法,只可用来对列表进行排序,是在原序列上进行修改,不会产生新的序列
    • 内置的sorted方法可以用于任何迭代的对象(字符串、列表、元组、字典等)会产生一个新的序列,旧的对象依然存在,不需要旧的序列可以采用sort方法

    1.sort()方法

    seq = [1,3,5,4,2,6]
    seq.sort()
    print(seq)
    

    输出如下所示:

    [1, 2, 3, 4, 5, 6]
    

    2.sorted()方法

    seq = [1,3,5,4,2,6]
    s = sorted(seq)
    print(s)
    

    输出如下所示:

    [1, 2, 3, 4, 5, 6]
    

    3.按列表a1中字典元素的键age由大到小排序

    a1 = [{'name':'a','age':20},{'name':'b','age':30},{'name':'c','age':25}]
    
    print(sorted(a1,key=lambda x:x['age'],reverse=True))
    

    输出如下所示:

    [{'name': 'b', 'age': 30}, {'name': 'c', 'age': 25}, {'name': 'a', 'age': 20}]
    

    八、列表中常用的方法

    方法描述
    list.append(x)把一个元素添加到列表的结尾
    list.extend(L)通过添加指定列表的所有元素来扩充列表
    list.insert(i,x)在指定位置插入一个元素,第一个参数是准备插入到其前面的那个元素的索引。例如a.insert(0,x)会插入到整个列表之前
    list.remove(x)删除列表中值为x的第一个元素。没有这样元素,就会返回一个错误
    list.pop([i])从列表的指定位置移除元素,并将其返回。没有指定索引,a.pop()返回最后一个元素。
    list.clear()移除列表中的所有项,等于del a[:]
    list.index(x)返回列表中第一个值为x的元素的索引。没有匹配的元素就返回一个错误
    list.count(x)返回x在列表中出现的次数
    list.sort()对列表中的元素进行排序
    list.reverse()倒排列表中的元素
    list.copy()返回列表的浅复制,等于a[:]
    • list可以看作一个对象,对象有很多中方法,调用方法是:对象.方法,append是这个对象的方法
    • 对象可以理解为人,方法append类似这个人可以跑步、吃饭、打球
    #list可以看作一个对象,append是这个对象的方法
    # 对象可以理解为人,方法append类似这个人可以跑步、吃饭、打球
    list1 = ['a','b','c']
    
    list1.append('d')
    
    print(list1)
    
    list1.extend(['1','2','3'])
    print(list1)
    

    输出如下所示:

    ['a', 'b', 'c', 'd']
    ['a', 'b', 'c', 'd', '1', '2', '3']
    

    九、列表生成式

    用来创建列表的表达式就是列表生成式,也被称为列表推导式。

    • 每个列表生成式都在for之后跟一个表达式,然后有零到多个for或if子句。返回结果是一个根据表达从其后的for和if上下文环境中生成出来的列表。
    • 列表生成式的语法:[表达式 for 循环]
    list1 = [x+1 for x in range(1,8)]
    print(list1)
    

    输出如下所示:

    [2, 3, 4, 5, 6, 7, 8]
    

    十、字典内置函数

    函数及描述描述
    len(dict)计算字典中的元素个数,键的总数
    str(dict)输出字典,以可打印的字符串表示
    type(variable)返回输入变量类型,如果变量是字典就返回字典类型
    radiansdict.clear()删除字典内所有元素
    radiansdict.copy()返回一个字典的浅复制
    radiansdict.fromkeys()创建一个新字典,以序列seq中元素做字典的键,val为字典所有键对应的初始值
    key in dict键在字典dict里返回True,否则返回False
    radiansdict.items()以列表返回可遍历的(键、值)元组数组
    radiansdict.keys()返回一个迭代器,可以使用list()转换为列表
    radiansdict.setdefault(key,default=None)和get类似,键不存在字典中,将会添加键并将值设为default
    radiansdict.update(dict2)把字典dict2的键/值对更新到dict里
    radiansdict.values()返回一个迭代器,可以使用list()转换为列表
    pop(key[,default])删除字典给定键key所对应的值,返回值为被删除的值。key值必须给出,否则,返回default值
    popitem()随机返回并删除字典中的一对键和值(一般删除末尾对)

    使用pop和del删除字典中的name字段

    dic = {"name":"刘备","age":19}
    dic.pop("name")
    print(dic)
    
    dic = {"name":"刘备","age":19}
    del dic["name"]
    print(dic)
    

    输出如下所示:

    {'age': 19}
    {'age': 19}
    

    合并两个字典

    dic1 = {"name":"刘备","age":19}
    
    dic2 = {"hobby":"足球","money":100}
    
    dic1.update(dic2)
    print(dic1)
    

    输出如下所示:

    {'name': '刘备', 'age': 19, 'hobby': '足球', 'money': 100}
    

    十一、集合常见内置方法

    集合常见内置方法如下表所示:

    方法描述
    add()为集合添加元素
    clear()移除集合中的所有元素
    copy()复制一个集合
    difference()返回多个集合的差集
    discard()删除集合中指定的元素
    intersection()返回集合的交集
    isdisjoint()判断两个集合是否包含相同的元素,没有则返回True,否则返回False
    issubset()判断指定集合是否为该方法参数集合的子集
    issuperset()判断该方法的参数集合是否为指定集合的子集
    pop()随机移除元素
    remove()移除指定元素
    symmetric_difference()返回两个集合中不重复的元素集合
    union()返回两个集合的并集
    update()给集合添加元素

    给定两个列表找出相同的元素和不同的元素

    list1 = [1,2,3]
    list2 = [3,4,5]
    
    set1 = set(list1)
    set2 = set(list2)
    
    print(set1&set2)
    print(set1^set2)
    

    输出如下所示:

    {3}
    {1, 2, 4, 5}
    
    展开全文
  • 列表元组字典集合之间的关系以及区别

    千次阅读 多人点赞 2021-03-11 21:30:10
    字符串、列表元组字典1.字符串2.列表 1.字符串 1.1 Python中的字符串可以使用单引号、双引号和三引号(三个单引号或三个双引号)括起来,遇到重复使用时可以使用反斜杠\转义特殊字符。 使用转义字符: my_str = ...
  • 1、列表 list = ['word',123]  特点:元素可重复,类型可以不同(这也是和数据最本质的区别),可修改 li1 = [123,123,234,'happy'] li[1] = 456(使用索引标记来为某个特定的、位置明确的元素赋值,但是不能为一个...
  • 列表元组字典集合

    2021-03-16 02:13:32
    1.列表列表是处理一组有序的数据结构,可以读写,添加和删除,或者搜索列表里的元素。因为可以添加和删除,所以...元组元组列表非常相似,用()来表示,但是元组是不可变的,不能修改元组元组可以嵌套3.字典字...
  • 字典中的“键”可以是Python中任意不可变数据,如整数、实数、复数、字符串、元组等,但是不能使用列表集合字典或其他可变类型作为字典的“键”。另外,字典中“键”不允许重复,而“值”是可以重复的。 9、...
  • 数据结构 列表 元组  元组是可以用一个变量()对象存储多个数据的容器数据类型,特殊之处在于元组的元素不能修改。事实上在项目中尤其是多线程环境中可能更喜欢... 元组在创建时间和占用的空间上都优于列表。可以使
  • 老男孩 Python 自动化开发 02 Python数据结构 列表 元组 字典 集合 共16页.rar
  • python中的列表和c++的数组很像,同样是存储多个数据。 和c++的不同之处,c++必须是规定类型,如int a[10];在python中可以保存n个数据,并且每个数据类型可以不一样。 1.列表的定义 names=["小红",小李] int a[10]...
  • 列表的方法: 格式: 列表名称.方法名字() index() 索引 count() 求列表元素个数 append( ) 在列表末尾加入一个元素该元素可以是任意数据类型 extend( ) 在列表末尾一次性追加另一个列表或可迭代对象中的多个值 ...
  • 【python学习】列表元组字典集合(详解)

    千次阅读 多人点赞 2022-03-31 16:34:55
    关注作者,持续阅读作者的文章,学习更多知识! ... 一、列表 列表(list)是Python中的一种数据结构,它可以存储不同类型的数据。...3.每个元素的排列是有序号的,元素相同但排列不同的列表属于不同的列表。 4...
  • Python列表元组字典集合#总结
  • 元组列表字典集合

    千次阅读 2021-01-10 15:24:13
    一、元组(tuple): 1.定义: t=(1,2,3)每个数据间用,隔开。当只有一个元素时,元素后加“,”。(不加会被当作int型) 2.下标:与字符串相同,t[2] 一个元素一个下标。 3.不允许被修改 4.切片:t[起始:终止:...
  • 列表元组字典集合的区别

    千次阅读 2021-10-19 20:53:50
    列表元组字典集合的区别 按照元素是否有序(每个元素有固定的位置)可分为有序和无序。其中字符串、列表元组中的元素有序,集合字典中的元素是无序的。 按照元素是否可以修改可分为可变组合和不可变组合...
  • 元组(tuple):有序,不可更改,可以有重复的成员 集合(set):无序,无索引,没有重复的成员。 字典 (Dictionary):无序,可更改,有索引,没有重复的成员 列表[](list)(有序,可更改,可以有重复的成员) ...
  • 1.列表元组字典是有顺序的,而集合是没顺序的 2.列表是以方括号形式表示,元组是以圆括号表示,字典以花括号表示,集合则是以[()]的形式表示 3.列表是可变对象,它支持在原处修改的操作.也可以通过指定的索引和分...
  • python基础之列表元组字典集合
  • 列表元组字典集合,都用于存放数据,它们区别总结如下: 项目 列表 元组 字典 集合 关键字 list tuple dict set 是否可变 可变 不可变 可变 可变 是否有序 有序 ...
  • python变量 数据类型 列表 元组 字典变量数据类型数据拼接列表添加列表元素修改元素删除列表元素组织列表确定列表长度创建数值列表操作列表元组元组拼接元组列表字典创建字典列表取值字典删除增加修改 变量 变量...
  • 1.1 列表(list): 1.2 元组(tuple): 1.3 字典(dict ): 1.4 集合(set): 2.创建 2.1 创建列表 2.2 创建元组 2.2 创建字典 2.4 创建集合 3.查找 3.1 查找列表元素 3.2 查找元组元素 3.3 查找...
  • 主要介绍了Python字符串、列表元组字典集合,结合实例形式详细分析了Python字符串、列表元组字典集合常见函数使用方法及相关操作注意事项,需要的朋友可以参考下
  • python中列表 元组 字典 集合的区别

    千次阅读 2018-12-14 10:23:23
    列表 元组 集合 字典 英文 list tuple set dict 定义 定义[],数据之间使用,分割 定义(),数据之间用,分割 定义用 {} 或 set() 字典的每个键值 key=&gt;value 对用冒号 ...
  • **python中列表 元组 字典 集合

    千次阅读 2021-01-30 05:45:01
    列表 元组 字典 集合的区别是python面试中最常见的一个问题。这个问题虽然很基础,但确实能反映出面试者的基础水平。1.列表列表是以方括号“[]”包围的数据集合,不同成员以“,”分隔。列表的特点:有序,数据可变,...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 95,273
精华内容 38,109
关键字:

列表元组字典集合的比较