精华内容
下载资源
问答
  • 列表字典集合
    万次阅读 多人点赞
    2021-03-11 21:30:10

    1.必看

    1.1列表、元组、字典、集合的区别
    列表:顺序存储结构,占更多存储空间(默认存了指针),元素不必相同,用"[]“表示。
    元组:元组和列表在结构上没有什么区别,唯一的差异在于元组是只读的,不能修改。元组用“()”表示。
    字典:字典定义了键和值之间一对一的关系,但它们是以无序的方式储存的。定义 Dictionary 使用一对大(花)括号”{}"。(其中前三个也可称之为Python的数组类型)
    集合:用的比较少,无序不重复元素集。
    1.2
    序列都可以进行的操作包括索引,切片,加,乘,检查成员。
    此外,Python已经内置确定序列的长度以及确定最大和最小的元素的方法。
    1.3为什么有了列表还要有元组、字典、集合?
    降低程序的时间复杂度
    比如字典:Python字典因为在存储元素时,将key哈希转化到了存储地址,所以如果要在字典里查找某个元素的key,不需要循环字典,只需要进行同样的哈希计算就可以得到了。
    1.4本文属于学习笔记,所以很多具体的知识点并没有记录,关于具体知识点可以访问菜鸟教程

    2.列表、元组、字典、集合最基本的创建

    2.1
    列表的创建

    a = [1,2,3]
    

    字典的创建(字典中每一对数据都是‘键’和‘值’相对应的)

    a = {key1:value1,key2:value2}
    

    元组的创建

    t = (1,2,3)
    

    集合的创建

    s = {'s','e','t'}
    

    2.2
    用list()、tuple()、dict()、set()内置方法转换

    s = set([1,2,3])
    

    3.列表

    3.1列表的三个优点:
    1.列表里想装啥就装啥,即:他可以包含不同种类、任意类型的对象,甚至可以嵌套列表,专业点的词儿叫:异构性;所以,列表里面的数据可以是不同类型的数据。
    2.列表里装的元素都是有顺序的,可以按照位置序号获取单个元素,也可以用分片的方法来进行多个连续元素的获取,来个专业词汇,叫做:有序性。所以,列表的下标可以进行索引和切片。
    3.列表的大小和内容可以随意改变,在插入、删除、修改列表元素时,不需要建立一份新的列表拷贝,而是在原来的内存地址上直接修改列表对象。这个叫“本地可修改”。所以,列表可以删除元素,列表拼接等。
    3.2列表常见操作和方法
    1.列表的索引
    2.列表的分片操作
    3.列表删除元素
    4.列表的拼接
    5.列表的重复
    6.元素成员判断
    7.求列表的长度
    8.求列表的最大、最小值
    9.在列表中插入元素
    10.反转一个列表
    11.计算列表中指定元素x的个数
    12.查找列表中指定元素的位置
    13.列表的排序

    4.元组

    元组类似于列表,是一个基于位置的有序对象集合,但是元组一旦创建之后就不能更改,因此列表中修改元素的操作对于元组都不适用。

    • 为什么要使用元组?

    元组和其他不可变量类似于其他语言中“常量”的声明,它的不可变性提供了某种一致性,这样可以确保元组在程序中不会被另一个引用修改。
    Mark Lutz——《Learning Python》中文版

    5.字典

    5.1常见操作方法

    操作解释
    .key()获取所有键
    .values()获取所有值
    .items()获取所有“键+值”元组
    len()获取键值对的数量
    .get(key,default)获取键的值,若键不存在,则返回设定的默认值default(默认为None)–与[key]获取值的区别是,get方法遇到键不存在的时候会返回设定值,而直接索引遇到键不存在时会报错“missing-key”
    dict1.update(dict2)合并两个字典

    5.2索引

    dict1[key]
    #key是字典的键,返回的是对应的值value
    dict1.get(key)
    #get方法获取键的值,若键不存在,则返回设定的默认值default(默认为None)--与`[key]`获取值的区别是,get方法遇到键不存在的时候会返回设定值,而直接索引遇到键不存在时会报错“missing-key”
    

    5.3遍历

    for i in dict1.keys():
    	print(i, dict1[keys]) 
    # 遍历字典中所有的键,并输出键值对 
    for i in dict1: 
          ...
    # 该方法与上述方法等价 
    for keys, values in dict1.items():
         ... 
    # 遍历字典中所有的键值对 
    

    5.3排序
    1.①借助.keys()方法和list()函数将键提取成list,对list排序后输出

    D = {'a':1, 'c':3, 'b':2}
    D1 = list(D.keys())
    D1.sort()
    for i in D1: 
        print(i, D[i])
    # 输出:
    # a 1
    # b 2
    # c 3
    

    ②借助内置的sorted()函数可对任意对象类型排序,返回排序后的结果。
    tips:对于sorted(字典)来说,返回的是排序好的keys(以list的形式)

    D = {'a':1, 'c':3, 'b':2}
    for i in sorted(D):
        print(i, D[i])
    # 输出:
    # a 1
    # b 2
    # c 3
    

    2.用字典的值对字典进行排序,将{1: 2, 3: 4, 4:3, 2:1, 0:0}按照字典的值从大到小进行排序。

    a = {1:2,3:4,4:3,2:1,0:0}
    sorted_a = sorted(a.items(),key=lambda a:a[1],reverse=False)
    print(sorted_a)
    

    ★sorted(iterable, key=lambda a:a[1], reverse=False)
    ①其中iterable是可迭代对象
    ②reverse = True 降序 , reverse = False 升序(默认)
    ③key – 主要是用来进行比较的元素,只有一个参数,具体的函数的参数就是取自于可迭代对象中,指定可迭代对象中的一个元素来进行排序。
    ④key=lambda a:a[1],是个lambda表达式,冒号右边的值返还给a。而a[1]表示a下标为1的值返还给a,最后,lambda表达式的值让key这个变量来指向。

    6.集合

    6.1

    • 为什么使用集合?
      1.由于集合内元素是不重复的,因此可以将list或其他类型的数据转换成集合,从而过滤掉其中的重复元素
      2.通过集合的交并补等操作,可以比较列表、字符串以及其他可迭代对象的差异。

    6.2集合的常用操作

    set1 `&` set2 
    #交运算
    set1 `|` set2 
    #并运算
    set1 `-` set2 
    #差运算,set1减去set1 `&` set2部分
    

    6.3集合的常用方法

    set1.add('x')  
    #添加元素。注意:集合中只能包含可哈希的对象,即list,dict都不能嵌入到集合中
    set1.union(...)  
    #取并集,效果等同于 | ,但是括号里可以是list,tuple,其他dict甚至是dictset1.intersection(...)  
    #取交集,同上set1.issubset(set2)  
    #判断set1是否是set2的子集
    
    更多相关内容
  • python字符串, 列表, 字典, 集合方法说明
  • 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() 关键字清空字典
    
    展开全文
  • 元组,列表字典集合

    千次阅读 2021-01-10 15:24:13
    list)-1-i): if my_list[j] > my_list[j+1]: flag = True my_list[j],my_list[j+1] = my_list[j+1],my_list[j] if not flag: print(my_list) 三、字典(dict): 1.定义:d={“age”:18,“name”:“张三”,“sex”:...

    一、元组(tuple):
    1.定义:
    t=(1,2,3)每个数据间用,隔开。当只有一个元素时,元素后加“,”。(不加会被当作int型)

    2.下标:与字符串相同,t[2] 一个元素一个下标。

    3.不允许被修改

    4.切片:t[起始:终止:步长] 当步长为负数时,起始默认为-1。

    5.内置函数:len() type() max() min() sum() sorted() 排序

    6.操作:

    t = (1,2,3)
    t.count("x")          #统计x出现的个数
    t.index(5)            #第一次出现5的下标,即索引
    
    
    

    7.遍历

    for i in range(len(t)):
        print(i)
    for t1 in t:
        print(t1)
    
    

    二、列表(list):
    1.定义:[1,“a”,2] []中必须是9个类型中的一个。

    2.下标:与字符串,元组相同

    3.可以修改

    4.切片:与字符串,元组相同

    5.内置函数:type(),len(),sorted(),{max,min,sum(需要是同一类型)}

    6.操作:

    list = [1,2,3,4]
    list.count()            # 统计个数
    list.index()            #查找(“要查的内容”,起始,终止)
    list.append("x")        #追加,在列表,末尾加上x.因为没有返回值,不能直接放在print()里!
    list.pop()              #删除最右侧的元素,并返回被删元素。
    list.sort()             #排序  必须是同一类型,无返回值
    s = list.copy()         #复制list的值给s(浅复制)
    list.reverse()          #反转  无返回值
    list.remove()           #删除,只能删除一个
    list.remove(list[2])    #指定位置删除
    list.insert()           #插入 (下标,“x”)  在下标处插入x
    list.clear()            #清空
    list.extend("123")      #将123加入list中[.......,"1","2","3"]
    #list.extend(1,2,3)           [.......,1,2,3]
    #list.extend[1,2,3]           [.......,1,2,3]
    
    

    7.遍历:

    for i in range(len(list)):
        print(i)
    for s in list:
        print(s)
    
    
    

    8.排序:冒泡排序,选择排序,插入排序,基数排序,快速排序,希尔排序,堆排序(大根堆和小根堆) 归并排序

    冒泡排序

    my_list = [8,6,1,7,4,0,6,2]
    for i in range(len(my_list)):
        flag = False
        for j in range(len(my_list)-1-i):
            if my_list[j] > my_list[j+1]:
                flag = True
                my_list[j],my_list[j+1] = my_list[j+1],my_list[j]
    if not flag:
        print(my_list)
    
    

    三、字典(dict):
    1.定义:d={“age”:18,“name”:“张三”,“sex”:“男”}
    键:key——value(值)

    2.没有下标,可以通过键来获取值 如: d[“age”]

    3.value可以修改

    4.没有切片

    5.内置函数:type(),len(), sorted(),{max,min,sum(按照键比大小和排序)}

    6.操作:

    #     print(my_list)
    d={"age":18,"name":"张三","sex":"男"}
    d.copy()            #浅复制
    d.clear()           #清楚
    f=d.pop("x","y")    #删掉指定的键并返回x所对应的值,如果没有x,返回y
    print(f)
    d.get("x","y")      #获取x的值,若没有返回y
    d.keys()            #取所有键,并返回成列表
    d.items()           #取所有键和值返回成列表中带有元组的形式
    d.update(age=88)    #将键age的value改为88,若没有age则在末尾加上“x”:y。   没有返回值
    
    
    

    7.遍历:

    for key,value in d.items():
        print(key,value)
    for key in d.keys():    #对键循环
        print(key,d.get(key))
    for valus in d.values():
        print(valus)
    
    
    

    四、集合(set):
    1.定义:d={1,“a”,3014,False}

    2.没有下标

    3.修改: s.update(“b”)增加

    4.没有切片

    5.内置函数:type,len,sorted,max,min,sum(都是数字可以求和)

    6.操作:

    s = {1,"a",2,3.14,"s"}
    ss = {1,"s",6,7.14,"k"}
    s.pop()             #删除
    s.remove(3.14)      #删除3.14
    s.add(200)          #添加200
    s.difference(ss)    #取s中ss不一样的元素,并返回一个新的集合
    s.difference_update(ss)#返回s中与ss不一样的元素(删掉s中与ss的元素)
    
    

    7.遍历:

    for d in s:
        print(d)
    
    
    
    展开全文
  • 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}
    
    展开全文
  • 本文详细归纳整理了Python中列表字典、元组、集合数据结构。分享给大家供大家参考。具体分析如下: 列表:复制代码 代码如下:shoplist = [‘apple’, ‘mango’, ‘carrot’, ‘banana’] 字典:复制代码 代码如下...
  • 【python学习】列表、元组、字典集合(详解)

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

    千次阅读 2021-10-19 20:53:50
    列表,元组,字典集合的区别 按照元素是否有序(每个元素有固定的位置)可分为有序和无序。其中字符串、列表和元组中的元素有序,集合字典中的元素是无序的。 按照元素是否可以修改可分为可变组合和不可变组合...
  • 列表、元组、字典集合区别 1、列表、元组、字典集合区别 1.1.列表 1.1.1 定义: ​ 列表式有序集合,没有固定大小,能够保留任意数量数据类型的Python对象;创建一个列表,只要把逗号分隔的不同的数据项使用方...
  • js代码-如何在字典列表集合中根据条件筛选数据?
  • 1.列表,元组,字典是有顺序的,而集合是没顺序的 2.列表是以方括号形式表示,元组是以圆括号表示,字典以花括号表示,集合则是以[()]的形式表示 3.列表是可变对象,它支持在原处修改的操作.也可以通过指定的索引和分...
  • 1.任意对象的有序集合 列表是一组任意类型的值,按照一定顺序组合而成的 2.通过偏移读取 组成列表的值叫做元素(Elements)。每一个元素被标识一个索引,第一个索引是0,序列的功能都能实现 3.可变长度,异构以及任意...
  • 主要介绍了Python列表推导式、字典推导式与集合推导式用法,结合实例形式分析了Python三种推导式的概念、使用方法及相关注意事项,需要的朋友可以参考下
  • 主要介绍了Python字符串、列表、元组、字典集合,结合实例形式详细分析了Python字符串、列表、元组、字典集合常见函数使用方法及相关操作注意事项,需要的朋友可以参考下
  • 集合类型及操作集合类型定义集合处理函数及方法集合类型应用场景序列类型...列表处理函数及方法字典类型及操作字典类型定义字典处理函数及方法字典类型应用场景总结比较1、集合类型及操作2、序列类型及操作3、字典类型...
  • 今天小编就为大家分享一篇python 列表字典集合的添加和删除操作,有很好的参考价值,希望对大家有所帮助。一起跟随小编过来看看吧
  • 定义 方法 列表 可以包含不同类型的对象,可以增减元素,可以跟其他的列表结合或者把一个列表拆分,用[]来定义的 eg:aList=[123,’abc’,4.56,[...5.len(list):返回列表元素个数 6.sorted(list):使用字典序对列
  • 列表,元组,字典集合,都用于存放数据,它们区别总结如下: 项目 列表 元组 字典 集合 关键字 list tuple dict set 是否可变 可变 不可变 可变 可变 是否有序 有序 ...
  • 在Python中有4种内建的数据结构:列表、元组、字典集合。今天我们将会学习如何使用它们,以及它们如何使编程变得简单。 在开始讲解之前小编在这磨叽两句 小编本身就是一名python开发工程师,我自己花了三天时间...
  • 列表字典、元组、集合的特点
  • python中数据结构之列表,元组,字典集合

    万次阅读 多人点赞 2018-09-01 14:42:21
    dictionary(字典)是除列表以外 python 中最灵活的数据类型 字典同样可以用来存储多个数据,通常用于存储描述一个物体的相关信息 2 字典列表的区别 列表是有序的对象集和 字典是无序的对象集和 3 字典用 {} ...
  • 1.任意对象的有序集合 列表是一组任意类型的值,按照一定顺序组合而成的 2.通过偏移读取 组成列表的值叫做元素,每一个元素被标识一个索引,第一个索引是0,序列的功能都能实现 3.可变长度,异构以及任意嵌套 列表中...
  • 列表,元祖,字典集合的使用场景对比及操作异同点分析
  • 列表、元组、字典集合、字符串均属于python3的标准数据类型。 字符串和元组属于不可变数据,即创建后不可修改。 列表字典集合属于可变数据,即创建后可以修改元素。 2.创建有元素的对象 3.创建没有元素的...
  • 说明:列表不可以转换为字典 ①转换后的列表为无序列表 a = {'a' : 1, 'b': 2, 'c' : 3} #字典中的key转换为列表 key_value = list(a.keys()) print('字典中的key转换为列表:', key_value) #字典中的value转换为...
  • 主要介绍了Python推导式,结合简单实例形式分析了Python列表推导式、字典推导式与集合推导式基本使用方法,需要的朋友可以参考下
  • 7. Python的元组&字典&集合1. 元组简介1.1 元组的 增1.2 元组的 改1.3 元组的 删1.4 元组的 查1.5 元组的 运算符 和 操作函数2. 可变对象2.1 第一个可变对象方法:修改列表2.2 第二个可变对象方法:修改索引2.3 第三...
  • 列表:就像动态大小的数组一样,用其他语言声明(C ++中的vector和Java中的ArrayList)。列表不必总是同质的,这使其...字典: 在Python中是数据值的无序集合,用于存储数据值(如地图),与其他仅将单个值作为元素的数
  • 列表、元组、字符串属于序列,字典属于映射,集合不属于2者其中之一。 在序列中,每个元素都有编号。 1、元组(tuple) 与列表类似,但元组是不可变的,可简单将其看作是不可变的列表,元组常用于保存不可修改的内容...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 281,588
精华内容 112,635
关键字:

列表字典集合