精华内容
下载资源
问答
  • python列表元组集合字典
    2020-01-13 22:52:35

    列表是任意对象的序列,列表用[ ]表示。

    将一组值打包到一个对象中,称为元组,元组用()表示。

    元组和列表的大部分操作相同,但是列表是不固定的,可以随时插入、删除,而元组一旦确定就不能再更改,所以系统为了列表的灵活性就需要牺牲一些内存,而元组就更为紧凑(注意:元组在定义过程中,字符串必须用单引号括起来)

    与列表和元组不同,集合是无序的,也不能通过索引进行访问。此外,集合中的元素不能重复。

    字典就是一个关联数组或散列表,其中包含通过关键字索引,所以比集合访问更方便。字典是Python解释器中最完美的数据类型。

    更多相关内容
  • 7. Python元组&字典&集合1. 元组简介1.1 元组的 增1.2 元组的 改1.3 元组的 删1.4 元组的 查1.5 元组的 运算符 和 操作函数2. 可变对象2.1 第一个可变对象方法:修改列表2.2 第二个可变对象方法:修改索引2.3 第三...
  • python容器:列表元组字典集合的思维导图
  • 很全面的讲解了Python列表 字典 文件操作等知识 很详细很有范 值得下载拥有
  • 列表元组字典集合区别 1、列表元组字典集合区别 1.1.列表 1.1.1 定义: ​ 列表式有序集合,没有固定大小,能够保留任意数量数据类型的Python对象;创建一个列表,只要把逗号分隔的不同的数据项使用方...

    1.1.列表

    1.1.1 定义:

    ​ 列表式有序集合,没有固定大小,能够保留任意数量数据类型的Python对象;创建一个列表,只要把逗号分隔的不同的数据项使用方括号括起来即可

    ​ 示例:

    ​ list1 = [‘Google’, ‘Runoob’, 1997, 2000]

    ​ list2 = [[‘a’, ‘b’, ‘c’], [1, 2, 3]]

    1.1.2 特点:

    ​ 列表内元素的个数和元素的值都可以改变;

    ​ 列表可以进行插入、删除、排序、修改操作;

    1.1.3 区别:

    ​ 列表与元组区别:列表内的值是可以修改的,元组不能修改;列表是可变类型而元组是不可变类型

    ​ 列表与字典区别:列表存储值,而字典存储键值对;列表是有序序列而字典是无序序列

    ​ 列表与集合区别: 列表是有序序列,集合是无序序列;列表内可以存储重复数据,集合内不能存储重复数据

    1.2元组

    1.2.1 定义:

    ​ 元组是与列表类似的有序集合;元组创建很简单,只需要在括号中添加元素,并使用逗号隔开即可

    ​ 示例:

    ​ tup1 = (‘Google’, ‘Runoob’, 1997, 2000)

    ​ tup3 = “a”, “b”, “c”, “d” # 不需要括号也可以

    1.2.1特点:

    ​ 元组中的元素不可修改

    1.2.3 区别:

    ​ 元组与字典区别:元组是不可变类型,字典式可变类型;元组是有序序列,字典是无序序列;元组值不可以更改,字典的值是可以更改的;

    ​ 元组与集合区别:元组是不可变类型,集合是可变类型,元组是有序序列,集合是无序序列;元组存储的值可以重复,集合存储的值不能重复

    1.3字典

    1.3.1 定义:

    ​ 字典是另一种可变容器模型,且可存储任意类型对象,字典的每个键值 key=>value 对用冒号 : 分割,每个对之间用逗号(,)分割,整个字典包括在花括号 {}

    ​ 示例:

    ​ tinydict = {‘name’: ‘runoob’, ‘likes’: 123, ‘url’: ‘www.runoob.com’}

    1.3.2 特点:

    ​ 键必须是唯一的,但值则可以是任意类型数据,键只能是不可变的,如字符串和数字

    1.3.3 区别:

    ​ 字典与集合区别:字典存储的值可重复,集合存储的值是不可重复;

    1.4集合

    1.4.1 定义:

    ​ 集合(set)是一个无序的不重复元素序列;使用大括号 { } 或者 set() 函数创建集合

    ​ 示例:

    ​ basket = {‘apple’, ‘orange’, ‘apple’, ‘pear’, ‘orange’, ‘banana’}

    1.4.2 特点:

    ​ 存储类似字典中键的值,不存储value;存储的元素在set中会被自动过滤;

    ​ 是一个无序的不重复元素序列

    参考资料:

    https://www.cnblogs.com/xh0203/p/12663745.html

    https://cloud.tencent.com/developer/article/1749774

    https://www.runoob.com/python3/python3-set.html

    ​ 感谢以上作者提供的参考

    展开全文
  • 列表元组字典集合

    一、列表(List)类型:

    List(列表) 是 Python 中使用最频繁的数据类型。列表可以完成大多数集合类的数据结构实现。它支持字符,数字,字符串甚至可以包含列表(即嵌套)。列表用" [ ] "标识,是 python 最通用的复合数据类型。

    1、创建列表对象的两种方法

    方式一:默认方法

    列表对象 = [元素1, 元素2, 元素3, …… , 元素N, ]

    	list01=[0,1,'HTML',True,[0,1]]
    	print(list01)#[0, 1, 'HTML', True, [0, 1]
    

    方式二:使用 range()内置函数

    列表对象 = list(range(stop))
    Python3 range() 函数返回的是一个可迭代对象(类型是对象),而不是列表类型, 所以打印的时候不会打印列表。
    range()参数说明:
    start: 计数从 start 开始。默认是从 0 开始。例如range(5)等价于range(0, 5);
    stop: 计数到 stop 结束,但不包括 stop。例如:range(0, 5) 是[0, 1, 2, 3, 4]没有5
    step:步长,默认为1。例如:range(0, 5) 等价于 range(0, 5, 1)

        list2=list(range(10))
        print(list2)#[0, 1, 2, 3, 4, 5, 6, 7, 8, 9]
        list2=list(range(3,10))
        print(list2)#[3, 4, 5, 6, 7, 8, 9]
        list2=list(range(3,10,2))
        print(list2)#[3, 5, 7, 9]
    

    2、列表访问:

    列表中值的切割也可以用到 [头下标 : 尾下标 : 步长] ,就可以截取相应的列表。
    从左到右下标索引默认 0 开始,从右到左下标索引默认 -1 开始,下标可以为空表示取到头或尾。
    常用函数有:
    .count(obj) : 统计某个元素在列表中出现的次数;
    .index(obj) : 从列表中找出某个值第一个匹配的索引位置;
    len(list) : 获取列表元素的个数;
    max(list) : 获取列表中的最大值;
    min(list) : 获取列表中的最小值;

        list2=list(range(10))
        print(list2)
        print(list2[0],list2[-1])#0 9
        print(list2[2:8])#[2, 3, 4, 5, 6, 7]
        print(list2[2:8:2])#[2, 4, 6]
        print(list2.count(2))#1
        print(list2.index(2))#2
        print(len(list2),min(list2),max(list2))#10 0 9
    

    3、列表更新:

    所谓的更新指的是对列表元素的 重新赋值、删除、添加等相关操作。
    常用的函数:
    **.append(obj) :**在列表末尾添加一个元素;
    .insert(index, obj) : 向指定位置前序添加一个元素
    .remove(obj) : 移除一个指定的元素;
    .reverse() : 反向列表中的元素;
    .sort() : 对列表进行排序;
    常用运算符:
    +(拼接列表)
    *(浅拷贝只拷贝了列表的“引用”,里面的内容其实是指向的同一个东西,修改其中一个元素时,后面的元素也发生了改变)


        list1=['HTML','CSS','JavaScript','XML']
        list1.append('python')
        print(list1)#['HTML', 'CSS', 'JavaScript', 'XML', 'python']
        list1.insert(2,'Hello')
        print(list1)#['HTML', 'CSS', 'Hello', 'JavaScript', 'XML', 'python']
        list1.remove('CSS')
        print(list1)#['HTML', 'Hello', 'JavaScript', 'XML', 'python']
        list1.reverse()
        print(list1)#['python', 'XML', 'JavaScript', 'Hello', 'HTML']
        list1.sort()
        print(list1)#['HTML', 'Hello', 'JavaScript', 'XML', 'python'] 根据ASCII排序
        print(list1+list(range(3)))#['HTML', 'Hello', 'JavaScript', 'XML', 'python', 0, 1, 2]
        print(list(range(3))*2)#[0, 1, 2, 0, 1, 2]
    

    4、List[] 与 list[:] 的区别:

    “ [ ] ”标识,是典型的引用操作,传址操作。
    “ [:] ”标识,是典型的赋值操作,传值操作 。

        list_1=list(range(4))
        list_2=list_1
        print(id(list_1))#1590116560960
        print(id(list_2))#1590116560960
        list_2=list_1[:]
        print(id(list_2))#1590116554048
    

    二、元组(Tuple)类型:

    Tuple(元组)类似于List(列表)。元组不能二次赋值(元组内的元素不允许更新),相当于只读列表。元组用“ ( ) "标识。内部元素用逗号隔开

    1、创建元组的方法

    组对象名称 = ( 元素1, 元素2, ……, 元素N )

        tup1=(1,'HTML',[1,2,3],True)
        print(tup1)#(1, 'HTML', [1, 2, 3], True)
    

    2、元组的特点

    元组与列表的所有操作基本类似,唯一不一样的地方是,元组的元素不允许被修改。

        tup2=tuple(range(5))
        print(tup2,type(tup2))#(0, 1, 2, 3, 4) <class 'tuple'>
        tup2[1]=2#错误,不能修改
        '''
            tup2[1]=2
            TypeError: 'tuple' object does not support item assignment
        '''
    

    3、元组访问:

    同列表

    三、字典(Dictionary)类型:

    字典(dictionary)是除列表以外python之中最灵活的内置数据结构类型。
    字典当中的元素是通过键来存取的,而不是通过偏移存取
    字典用“{ }”标识。字典由索引(key)和它对应的值value组成,是一个典型的“k-v值 ”数据结构。

    1、创建字典的方法:

    字典对象名称 = { }
    字典对象名称 = { key1 : value1, key2 : value2, …. , keyN : valueN }

        dic1={}
        dic1[0]='zhangsan'
        dic1[1]='man'
        print(dic1)#{0: 'zhangsan', 1: 'man'}
        dic2={'name':'zhangsan','age':18,'high':1.78}
        print(dic2)#{'name': 'zhangsan', 'age': 18, 'high': 1.78}
    

    2、字典(Dictionary)k-v 值在内存中的表现形式:

    k-v结构一般情况下在操作访问的时候都会使用key索引进行每个元素的读取操作
    由于key索引键会被频繁访问,因此索引键key存放在Stack栈内存中,而value值则存储在Heap堆内存中。且字典是随机存储形式,无序结构

    3、字典(Dictionary)访问:

    字典对象名称[ key ] #访问key对应的value值
    字典对象名称.keys #访问当前字典所有key索引键
    字典对象名称.values #访问当前字典所有valeus值

        dic2={'name':'zhangsan','age':18,'high':1.78}
        print(dic2)#{'name': 'zhangsan', 'age': 18, 'high': 1.78}
        print(dic2['name'],dic2['age'],dic2['high'])#zhangsan 18 1.78
        print(dic2.keys())#dict_keys(['name', 'age', 'high'])
        print(dic2.values())#dict_values(['zhangsan', 18, 1.78])
    

    四、列表[List]、元组(Tuple)和 字典{Dictionary}的异同点:

    从承载数据类型的结构角度看:Python的数据类型分为数字类型和非数字类型。
    数字类型包括:整型、长整型、浮点型和复数型。
    非数字类型包括:字符串、列表、元组和字典。

    共同点:

    都可以使用切片、连接(+)、重复(*)、取值(a[ ])等相关运算。
    截取方式相同:名称[头下标:尾下标]
    下标是从0开始算起,可以是正数或者负数,下标为空则表示取到头或者尾
    开始截取时,包含了下边界,而截取到最大范围不包括上边界 [ ) 。

    不同点:

    列表 可以直接赋值
    元组不可以赋值
    字典按照 dict[k]=v 的方式赋值

    五、补充:集合set

    集合是一个无序不重复元素的集。基本功能包括关系测试和消除重复元素。
    可以用大括号{}创建集合。注意:如果要创建一个空集合,必须用 set()而不是 {} ;后者创建一个空的字典。

    1、创建集合的方法:

    集合对象名称 = {元素1,元素2,…}
    集合对象名称 = {‘abc’} 会将abc创建为{‘a’, ‘b’, ‘c’}
    空集合:集合对象名称 = set()

        book={'Math','Language','English','Math'}
        print(type(book))#<class 'set'>
        print(book)#{'Language', 'English', 'Math'}删除重复的
        empyt_set=set()#创建空集合
        empyt_dic={}#空字典
        print(type(empyt_set),type(empyt_dic))#<class 'set'> <class 'dict'>
        set1=set('abc')
        print(set1)#{'a', 'c', 'b'}
    

    2、集合 Set 的关系操作(交、并、补):

    基本操作:
    .add(‘x’) # 添加一项
    .update([0,1,2]) # 添加多项

        num1=set(range(5))#创建一个数字集合
        num2={1,3}#创建一个数字集合
        print(num1,num2)#{0, 1, 2, 3, 4} {'o', 'h', 'l', 'e'}
        a=num1|num2#并集
        b=num1&num2#交集
        c=num1-num2 # 差集(在num1中不在num2中)
        d=num1^num2# 对称差集(项在num1或snum2中,但不会同时出现在二者中)
        print(a,b,c,d)#{0, 1, 2, 3, 4} {1, 3} {0, 2, 4} {0, 2, 4}
        num1.add(5)#添加一项
        num2.update([6,7,8,'abc'])#添加多项
        print(num1,num2)#{0, 1, 2, 3, 4, 5} {1, 3, 6, 7, 8, 'abc'}
    
    展开全文
  • 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}
    
    展开全文
  • 列表list定义符号:[]创建:[]直接创建 , list()可变性:可变是否有序:有序元素是否重复:可以重复切片:支持切片索引:支持索引访问:索引访问删除:del()list.remove(value)list.pop()修改插入:list[]=append()...
  • 主要介绍了Python字符串、列表元组字典集合,结合实例形式详细分析了Python字符串、列表元组字典集合常见函数使用方法及相关操作注意事项,需要的朋友可以参考下
  • 1、列表 list = ['word',123]  特点:元素可重复,类型可以不同(这也是和数据最本质的区别),可修改 li1 = [123,123,234,'happy'] li[1] = 456(使用索引标记来为某个特定的、位置明确的元素赋值,但是不能为一个...
  • ( ) 元组tuple,戴了枷锁的列表,不可改变 3. 字典directory {key : value} 字典directory, 即键值对,无序的序列 4. 集合set {value, value,} 集合set,在我的世界里,你就是唯一!数据具有唯一性,不支持索引...
  • 列表元组的区别 定义列表 定义元组 三、字典类型 # 获取字典中的值 四、集合类型 集合的定义方式 给集合添加元素 检查当前的元素是否在集合集合主要用于运算,交集,差集,并集,对称集合 列表用来...
  • Python语法——列表元组集合字典 综述: 列表(List) [ ] 是一种有序和可更改 的集合。允许重复的成员。 元组(Tuple) ( ) 是一种有序且不可更改的集合。允许重复的成员。 集合(Set) { } 是一个无序和无...
  • 一、列表 1.任意对象的有序集合 列表是一组任意类型的值,按照一定顺序组合而成的 ...列表可以当成普通的数组,每当用到引用时,Python总是会将这个引用指向一个对象,所以程序只需处理对象的操作。当
  • https://blog.csdn.net/Theahe/article/details/104042603传送门
  • python中的列表和c++的数组很像,同样是存储多个数据。 和c++的不同之处,c++必须是规定类型,如int a[10];在python中可以保存n个数据,并且每个数据类型可以不一样。 1.列表的定义 names=["小红",小李] int a[10]...
  • 列表元组字典集合,都用于存放数据,它们区别总结如下: 项目 列表 元组 字典 集合 关键字 list tuple dict set 是否可变 可变 不可变 可变 可变 是否有序 有序 ...
  • 本文详细归纳整理了Python列表字典元组集合数据结构。分享给大家供大家参考。具体分析如下: 列表:复制代码 代码如下:shoplist = [‘apple’, ‘mango’, ‘carrot’, ‘banana’] 字典:复制代码 代码如下...
  • 元组的元素是不可修改的; 列表的元素可变的; 字典的元素键是不可变的,键对应的值是可变的; 集合的元素是可变的。 2、创建空的方式不同 创建空元组: tup = (); 创建空列表: list = []; 创建空集合: sets = ...
  • python 数据类型 列表(可变数据类型): 列表的创建: [ ] 或者 list( ) 列表的索引: 由下标0开始 ,最后一个为-1 列表的切片: list[ start : end : step] 列表的计算: 支持+,-,* 等方法 列表的方法: ...
  • j最近看了python的相关理论,总觉得看一章写一页的手写笔记差点意思,今天刚好把该追的电视剧追完了,就来写个总结吧!作为我CSDN的开端~ 目录 1.简单介绍 1.1 列表(list): 1.2 元组(tuple): 1.3 字典...
  • Python 列表元组字典集合的区别 一、列表 1.任意对象的有序集合 列表是一组任意类型的值,按照一定顺序组合而成的 2.通过偏移读取 组成列表的值叫做元素(Elements)。每一个元素被标识一个索引,第一个索引是...
  • python基础之列表元组字典集合
  • python学习】列表元组字典集合(详解)

    千次阅读 多人点赞 2022-03-31 16:34:55
    列表(list)是Python中的一种数据结构,它可以存储不同类型的数据。不同元素以逗号分隔。 eg: A = [1,'zhangsan','a', [2, 'b']] 列表使用规则 1.使用方括号[]表示开始和结束。 2.不同元素以逗号分隔。 3.每个元素...
  • 集合类型及操作集合类型定义集合处理函数及方法集合类型应用场景序列类型及操作序列类型定义序列处理函数及方法序列类型应用场景(元组列表)元组类型及操作元组类型定义元组类型操作列表类型及操作列表类型定义列表...
  • Python元组字典

    2021-01-30 18:44:17
    Python元组列表类似,不同之处在于元组的元素不能修改。 元组使用小括号 ( ),列表使用方括号 [ ]。 元组创建很简单,只需要在括号中添加元素,并使用逗号隔开即可。 如下: tuple1 = (1, 2, 3, 4) tuple2 = ('...
  • 列表中的数据类型可以包含多种,包含数字、字符串、字典、布尔型等,并且列表中还可以嵌套列表 print(type([1, 2, 3, 4, 5, 6])) print(type(['Hello', 'World', 1, 6])) print(type(['Hello', 1, 2, True, 'a'])) ...
  • 列表元组、字符串属于序列,字典属于映射,集合不属于2者其中之一。 在序列中,每个元素都有编号。 1、元组(tuple) 与列表类似,但元组是不可变的,可简单将其看作是不可变的列表元组常用于保存不可修改的内容...
  • python列表元组字典的特点与区别

    千次阅读 2021-11-16 00:03:16
    一、列表元组字典的特点: 1、列表(list):[] 有序、有索引,值可重复/任意类型 2、元组(tuple):() 与列表一样,有序、有索引,值可重复/任意类型 3、字典(dict):{} 键值对(key-value) 无序,key是要唯一的,一般...
  • 数据结构 列表 元组  元组是可以用一个变量()对象存储多个数据的容器数据类型,特殊之处在于元组的元素不能修改。事实上在项目中尤其是多线程环境中可能更喜欢... 元组在创建时间和占用的空间上都优于列表。可以使

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 86,835
精华内容 34,734
关键字:

python列表元组集合字典