精华内容
下载资源
问答
  • 序列是一个基类类型,元组、列表是序列类型一种扩展,继承序列类型全部通用操作。 (1)集合set 集合就是我们数学学的集合集合最好应用是去重——集合类型所有元素无重复。可以利用{}或set()建立集合。 ...

    前排提示:元祖是错误的写法(带错别字),部分博客写为元祖系误,正确的说法为元组。

    首先了解序列。序列是具有先后关系的一组元素,它是一维元素向量,元素类型可以不同。元素间由序号引导,通过下标访问序列的特定元素。

    序列是一个基类类型,元组、列表是序列类型的一种扩展,继承序列类型的全部通用操作。

    (1)集合set

    集合就是我们数学学的集合,集合最好的应用是去重——集合类型所有元素无重复可以利用{}或set()建立集合

    注:print默认以换行符\n作为结尾,end=" "则使print以空格字符作为结尾。

    (2)元组tuple

    元组和列表在结构上没有什么区别(因为元组、列表是序列类型的一种扩展),唯一的差异在于元组是只读的,创建后不能修改。于是,有应用场景——数据保护:如果不希望数据被程序所改变,转换为元组类型。元组使用小括号()或tuple()创建。可以使用或不使用小括号。

    (3)列表list
    什么是列表呢?我觉得列表就是我们日常生活中经常见到的清单。比如,统计过去一周我们买过的东西,把这些东西列出来,就是清单。由于我们买一种东西可能不止一次,所以清单中是允许有重复项的。如果我们扩大清单的范围,统计我们过去一周所有的花费情况,那么这也是一个清单,但这个清单里会有类别不同的项,比如我们买东西是一种花费,交水电费也是一种花费,这些项的类型是可以使不同的。python的列表跟清单的道理是一样的,特点就是:可重复,类型可不同。类型不同也是跟数组最本质的区别了。

    列表创建后可以随意被修改(元组不可以)。python里的列表用[ ]或list()创建:


     

    (4)字典dict

    最后一个是字典。字典类型是“映射”的体现。字典是键值对的集合,键值对之间无序。采用大括号{}和dict()创建,键值对用冒号:表示。字典最大的价值是查询,通过键,查找值。

     

    下面是一些小例子:

    1、列表元组转其他

    # 列表转集合(去重)
    list1 = [6, 7, 7, 8, 8, 9]
    set(list1)
    # {6, 7, 8, 9}
    
    #两个列表转字典
    list1 = ['key1','key2','key3']
    list2 = ['1','2','3']
    dict(zip(list1,list2))
    # {'key1': '1', 'key2': '2', 'key3': '3'}
    
    #嵌套列表转字典
    list3 = [['key1','value1'],['key2','value2'],['key3','value3']]
    dict(list3)
    # {'key1': 'value1', 'key2': 'value2', 'key3': 'value3'}
    
    # 列表、元组转字符串
    list2 = ['a', 'a', 'b']
    ''.join(list2)
    # 'aab'
    
    tup1 = ('a', 'a', 'b')
    ''.join(tup1)
    # 'aab
    

    2、字典转其他

    # 字典转换为字符串
    dic1 = {'a':1,'b':2}
    str(dic1)
    # "{'a': 1, 'b': 2}"
    
    # 字典key和value互转
    dic2 = {'a': 1, 'b': 2, 'c': 3}
    {value:key for key, value in a_dict.items()}
    # {1: 'a', 2: 'b', 3: 'c'}
    

    3、字符串转其他

    # 字符串转列表
    s = 'aabbcc'
    list(s)
    # ['a', 'a', 'b', 'b', 'c', 'c']
    
    # 字符串转元组
    tuple(s)
    # ('a', 'a', 'b', 'b', 'c', 'c')
    
    # 字符串转集合
    set(s)
    # {'a', 'b', 'c'}
    
    # 字符串转字典
    dic2 = eval("{'name':'ljq', 'age':24}")
    
    # 切分字符串
    a = 'a b c'
    a.split(' ')
    # ['a', 'b', 'c']
    

    二、字典的分割、合并

    分割:
    base = {'A':1, 'B':2, 'C':3, 'D':4, 'E':5}
    subkey = ['C', 'E']
    subdict=dict([(key, base[key]) for key in subkey])
    print(subdict)——{'C': 3, 'E': 5}
    
    合并:
    方式一:
    d1={'user':'root','pwd':'1234'}
    d2={'ip':'127.0.0.1','port':8080}
    d3=dict(d1, **d2)
    print(d3)
    
    方式二:
    d1={'user':'root','pwd':'1234'}
    d2={'ip':'127.0.0.1','port':8080}
    d3={}
    for k,v in d1.items():
        d3[k] = v
    for k,v in d2.items():
        d3[k] = v
    print(d3)
    

    三、list分割、合并

    a=[1,2,3,4,5,6]
    b=['a','b','c','d']
    print(a+b)
    
    a=[1,2,3,4,5,6]
    b=['a','b','c','d']
    a+=b
    print(a)
    
    a=[1,2,3,4,5,6]
    b=['a','b','c','d']
    a.extend(b)
    print(a)
    
    a=[1,2,3,4,5,6]
    b=['a','b','c','d']
    a[0:0]=b
    print(a)
    
    li = ['a','b','c']
    res1=';'.join(li)
    res2=''.join(res1).split(';')

     

    展开全文
  • #TODO:python基本常识:列表和集合之间的转换 # ls = [“p”,“p”,“y”,“y”,123] #添加原始列表 # nls = set(ls) #列表转换成"集合“,集合的特点:不存在重复元素 # print(nls) # ls = list...
    #TODO 怎么去{}中的数据
    t=[5,6,7,9,'a','h']
    s=set(t)
    ss=list(s)
    print(t,s,ss)
    #TODO:python基本常识:列表和集合之间的转换
    # ls = [“p”,“p”,“y”,“y”,123] #添加原始列表
    # nls = set(ls) #列表转换成"集合“,集合的特点:不存在重复元素
    # print(nls)
    # ls = list(nls) #集合转换成列表
    # print(ls)
    # Python数据类型 列表、元组、集合、字典的区别和相互转换
    #TODO:一:数据类型 列表、元组、集合、字典的区别
    #               	列表          元组	    集合	                字典
    # 英文	            list	     tuple	    set	                      dict
    # 可变与不可变类型	可变类型	不可靠类型	可变类型	             可变类型
    # 可否重复	         是	          是	      否                      	是
    # 存储方式	         值	          值	    键(不能重复)	      键值对(键不能重复)
    # 是否有序	         有序	    有序	    无序	               无序,自动正序
    # 初始化	          [1,'a']	   ('a', 1)	  set([1,2]) 或 {1,2}	 {'a':1,'b':2}
    # 添加	          append	    只读	       add	                    d['key'] = 'value'
    # 读元素          	l[2:]	    t[0]	       无	                        dict['a']
    
    #TODO:二:列表、元组、集合、字典相互转换
    # # 列表转换集合(去重)
    # list1 = [1, 2, 3, 4, 1]
    # print(set(list1))
    # # {1, 2, 3, 4}
    #
    # # 列表转换集和或者重新赋值给一个新的集合变量 set1
    # list1 = [1, 2, 3, 4, 1]
    # set1 = set(list1)
    # print(set1)
    # # {1, 2, 3, 4}
    #
    #
    # # 两个列表转字典
    # list1 = ['key1', 'key2', 'key3']
    # list2 = ['1', '2', '3']
    # print(dict(zip(list1, list2)))
    # # {'key1': '1', 'key2': '2', 'key3': '3'}
    #
    #
    # # 嵌套列表转字典
    # list3 = [['key1', 'value1'], ['key2', 'value2'], ['key3', 'value3']]
    # dict(list3)
    # print(dict(list3))
    # # {'key1': 'value1', 'key2': 'value2', 'key3': 'value3'}
    #
    #TODO:三:字典转换为其他数据类型
    dic1 = {'a':1,'b':2}
    str(dic1)
    # "{'a': 1, 'b': 2}"
    
    # 字典key和value互转
    dic2 = {'a': 1, 'b': 2, 'c': 3}
    # {value:key for key, value in a_dict.items()}
    # {1: 'a', 2: 'b', 3: 'c'}
    # # 列表转字符串
    list4 = ['a', 'b', 'c']
    print(''.join(list4))
    #TODO:四:字符串转其他
    # 字符串转列表
    s = 'aabbcc'
    list(s)
    # ['a', 'a', 'b', 'b', 'c', 'c']
    
    # 字符串转元组
    tuple(s)
    # ('a', 'a', 'b', 'b', 'c', 'c')
    
    # 字符串转集合
    set(s)
    # {'a', 'b', 'c'}
    
    # 字符串转字典
    dic = eval("{'name':'ljq', 'age':24}")
    
    # 切分字符串
    a = 'a b c'
    a.split(' ')
    # ['a', 'b', 'c']
    
    # abc  
    #
    # # 列表转换为集合去重,并且集合转换为列表
    list1 = [1, 2, 3, 4, 1]
    list1 = set(list1)
    list2 = list(list1)
    print(list1,list2)
    
    i=[1,2,3,4,5,6,7,'s','d',5,4]
    ii=set(i) #  可以去重复
    list4 = ['a', 'b', 'c']
    print(''.join(str(i)))
    
    print(i,ii)
    
    展开全文
  • 列表推导式 [expression for val in old_list if condition] ...过滤出字符串列表中包含字母a字符串,并将首字母转换为大写 In [22]: str_list1 = ['denglun','xiaozhan','wangyibo','wuyifan','yueyunpeng','reba']

    列表推导式

    [expression for val in old_list if condition]
    相当于

    new_list = []
    for val in old_list:
    	if condition:
    		new_list.append(expression)
    

    示例:
    过滤出字符串列表中包含字母a的字符串,并将首字母转换为大写

    In [22]: str_list1 = ['denglun','xiaozhan','wangyibo','wuyifan','yueyunpeng','reba']
    
    In [23]: [x.capitalize() for x in str_list1 if x.find('a')!=-1]
    Out[23]: ['Xiaozhan', 'Wangyibo', 'Wuyifan', 'Reba']
    

    集合推导式

    {expression for val in old_set if condition}
    除用的是{}之外,其余与列表推导式很像

    In [24]: {x.capitalize() for x in str_list1 if x.find('a')!=-1}
    Out[24]: {'Reba', 'Wangyibo', 'Wuyifan', 'Xiaozhan'}
    

    字典推导式

    {key-expression : value-expression for value in old_dict if condition}

    In [25]: keys=[1,2,3,4,5]
    
    In [26]: values=['xiaohua','xiaoming','erha','hashiqi']
    
    In [27]: {key:len(value) for key, value in zip(keys,values)}
    Out[27]: {1: 7, 2: 8, 3: 4, 4: 7}
    

    嵌套列表推导式

    相当于for循环嵌套

    In [1]: all_dogs = [['jinmao','erha','alasijia','zangao'],['keji','taidi','jiwawa']]
    
    In [2]: [dog for dogs in all_dogs for dog in dogs if len(dog)>4]
    Out[2]: ['jinmao', 'alasijia', 'zangao', 'taidi', 'jiwawa']
    
    In [3]: [dog for dogs in all_dogs for dog in dogs if len(dog)>4 and len(dogs)>3]
    Out[3]: ['jinmao', 'alasijia', 'zangao']
    
    In [7]: str1=['zhang','zhao','yao']
    In [8]: str2=['xiaohua','huahua','xiaohong']
    
    In [9]: [x+y for x in str1 for y in str2]
    Out[9]:
    ['zhangxiaohua',
     'zhanghuahua',
     'zhangxiaohong',
     'zhaoxiaohua',
     'zhaohuahua',
     'zhaoxiaohong',
     'yaoxiaohua',
     'yaohuahua',
     'yaoxiaohong']
    
    展开全文
  • Python列表、元组、集合、字典区别相互转换 列表的一般用法: list1 = ["python", 1, 6, [2, "book"], "code"] #list内元素数据类型可以不同,也可以是另外一个list print (list1) #使用下标索引来访问列表中...

    # 查询变量所指的对象类型
    x = 1
    type(x)
    #判断变量所指类型是否是某类型
    isinstance(x, int)
    #删除变量
    del x
    

    列表的一般用法:

    list1 = ["python", 1, 6, [2, "book"], "code"] #list内元素的数据类型可以不同,也可以是另外一个list
    print (list1)
    
    #使用下标索引来访问列表中的值,同样你也可以使用方括号的形式截取字符,如下所示:
    print (list1[:])  #访问全部
    print (list1[0],list1[1])  #访问第0个元素和第一个元素
    print (list1[-1],list1[-2]) # 打印出序列的最后一个元素和倒数第二个元素
    
    print (list1[0:3]) #切片,此操作左闭右开
    print (list1[:3])  #切片,从头开始,取出索引值0,1,2的元素,不包含索引值为3的元素
    print (list1[-3:]) #切片,从后向前数索引,也只能从左往右切片
    print (list1[0:-1:2]) #按步长切片,从第一个开始,步长为2,不包含最后一个元素
    print (list1[::2]) #按步长切片,从第一个开始,步长为2,包含最后一个元素
    
    #更新
    list[1] = 14  # 列表list1 中第1个元素的值更新为14
    
    #添加元素  append()  extend()
    list1.append('bar')  # 在列表的最后加一个新元素
    list1 = list1 + ["apple"]  #直接相加法
    
    #在指定位置添加元素 insert()
    list1.insert(1, 'hello')  #在列表第1个位置(0为起始位置)添加元素
    
    #删除元素 pop()
    x = list1.pop()      # 移除列表的最后一个元素,同时将这个元素返回到一个变量中
    y = list1.pop(1)    #删除列表第1个位置(0为起始位置)的元素
    del list1[2]  #删除第2个(0为起始位置)元素
    

    你可以找到更多的列表使用方法,在以下文档中。

    切片
    除了一次访问列表中的一个元素,Python还提供了一种更高效的使用方式叫做切片。下面我们举几个例子。

    nums = [0, 1, 2, 3, 4]
    print(nums)
    print(nums[2:4]) # 得到一个切片,下标从2到4,但是不包括4
    print(nums[2:]) # 得到一个切片,下标从2到列表结束
    print(nums[:2]) # 得到一个切片,下标从开始到2,不包括2
    print(nums[:]) # 得到整个列表的元素
    print(nums[:-1]) # 得到一个切片,下标从开始到最后一个元素,不包括最后一个元素
    nums[2:4] = [8, 9] # 将列表中下标从2到4(不包括4)的切片替换成新的元素
    print(nums)
    

    如果想取得每个元素的下标,可以通过调用内置函数enumerate来实现。

    #enumerate() 函数用于将一个可遍历的数据对象(如列表、元组或字符串)组合为一个索引序列,同时列出数据和数据下标,一般用在 for 循环当中
    #enumerate(sequence, [start=0])  sequence:一个序列、迭代器或其他支持迭代对象。start:下标起始位置。
    animals = ['cat', 'dog', 'monkey']
    for idx, animal in enumerate(animals):
        print('#{}: {}'.format(idx + 1, animal))
    

    一种更高级的列表循环方法,可以避免我们创建一个空列表进行元素的添加

    nums = [0, 1, 2, 3, 4]
    squares = [x ** 2 for x in nums]
    print(squares)
    

    嵌套列表

    list1 = [["a","b","c"],[1,2,3]]
    #访问成员b
    list1[0][1]
    
    #返回列表元素的个数 len()
    count = len(list1)  #返回的是 list1 最外层的元素个数
    print(count)  # 2
    
    #移除列表中的元素,并且返回这个值 pop()
    l = list1.pop(1)
    
    #对列表中的元素进行排序 sort()
    l.sort()
    print(l)  # [1, 2, 3]
    
    #查找列表中第一个匹配的元素的索引值 index()
    list1 = [12,11,13,11]
    i = list1.index(11)
    print(i)  # 1
    

    集合(set)
    集合里面的元素没有顺序关系,同时里面也没有重复的元素。
    两种声明方法:1.使用{ };2. set( )

    animals = {'cat', 'dog'}
    print('cat' in animals)   # 验证该元素是否在集合中 in
    print('fish' in animals)
    animals.add('fish')       # 在集合里面添加元素 add()
    print('fish' in animals)
    print(len(animals))       # 打印出集合的元素个数 len()
    animals.add('cat')         
    print(len(animals)) 
    animals.remove('cat')     # 从集合里面移除某个元素  remove()
    print(len(animals))
    
    #两个集合间的运算
    a = {"a","b","c","d","e","f"}
    b = {"a","b","c","x","y","z"}
    
    print(a & b)  #交 {'a', 'b', 'c'}
    print(a | b)  #并 {'e', 'd', 'a', 'b', 'z', 'x', 'y', 'c', 'f'}
    print(a ^ b)  #集合 a,b 中不同时存在的 {'z', 'e', 'y', 'x', 'd', 'f'}
    
    #集合添加元素 add()
    my_set = {"a","b","c"}
    my_set.add("d")
    print(my_set)
    
    #移除指定元素  remove()
    my_set.remove("a")
    print(my_set)
    
    #随机移除一个元素 pop()
    pop_param = my_set.pop()
    print(pop_param)
    print(my_set)
    
    #计算集合的个数 len()
    print(len(my_set))
    
    #清空集合 clear()
    my_set.clear()
    print(my_set)
    
    #判断 a 是否在集合里 in / not in
    print("a" in my_set)  
    print("a" not in my_set)
    

    可以在以下文档查看关于集合的所有信息。

    字典(dict)
    字典是一种可变容器类型,也是可以存储任意类型的对象。
    字典里面存在的都是数据对,这些数据都是以(key, value)的形式存在,且存在映射关系。

    d = {'cat': 'cute', 'dog': 'furry'}  # 创造一个字典
    print(d['cat'])       # 取得字典中的某个元素
    print('cat' in d)     # 判断字典中key是否有该元素
    
    d['fish'] = 'wet'     # 字典中添加一个新元素
    print(d['fish'])      # 打印出字典中的元素
    print(d.get('monkey', 'N/A'))  # 如果元素在字典的key中,返回其对应的值,否则返回get中的值
    print(d.get('fish', 'N/A'))
    
    del d['fish']         # 从字典中移除某个元素
    print(d.get('fish', 'N/A')) # fish被移除之后,不能显示出'wet'
    print(d['pig'])
    
    d = {"a":12, "b":13, "c":14}
    
    #访问
    keys = d.keys()  #keys()函数以列表返回一个字典所有的键
    values = d.values() #values()函数以列表返回字典中的所有值
    print(keys)    # 输出结果为dict_keys(['a', 'b', 'c'])
    print(values)  # 输出结果为dict_values([12, 13, 14])
    
    print(d["a"])  # 输出结果为 12
    
    #增加
    d["d"] = 15
    
    #更新
    d["a"] = 20
    
    #删除 del
    del d["b"]
    
    #判断键是否在字典中 in / not in
    i = "c" in d
    print(i)
    
    #清空字典 clear()
    d.clear()
    print(d)
    

    在这里插入图片描述
    在这里插入图片描述
    参考:python 字典操作提取key,value

    元组(Tuple)
    元组和列表类似,但是元组是无法改变的。同时一个最大的不同是元组可以作为字典中的key,而列表不可以。
    元组(Tuple)中只有一个元素时,t = (1, ) 写一个逗号,消除歧义

    d = {(x, x + 1): x for x in range(10)} # 使用元组创造一个字典
    t = (5, 6)        # 创造一个元组
    print(type(t))    # 打印出元组的类型
    print(d[t])       # 打印出字典中对应于(5, 6)的元素
    print(d[(1, 2)])  # 打印出字典中对应于(1, 2)的元素
    

    下面的文档有更多关于元素的信息。

    展开全文
  • 1.str中的join算法,将列表转换成字符串,并用'_'(或其他) 1 li=['李嘉诚','马化腾','刘嘉玲','黄海峰',] 2 s='_'.join(li) 3 print(s) #李嘉诚_马化腾_刘嘉玲_黄海峰 2.循环删除列表中的每个元素 li=['...
  • Python中数据类型:数值、字符串、元组、列表以及字典和集合 其中有数值类型包含: 整型(int)、浮点型(float)以及布尔型(bool) 整型 通常理解为整数 则有正整数和负整数,不带有小数点; 浮点型 即带有小数点...
  • python中集合的其中一种作用是去除字符串或者列表中的重复元素。这一功能是十分有用的。比如: 输出为: 光知道这些是不够的,使用集合去重的时候有几个特性需要注意。 我们再来看上述代码,发现列表改为集合后...
  • 总结python中列表的用法字节用法! 一、列表 1、列表介绍 列表时Python中最基本也是最常用数据结构之一,它时一个有序可重复元素集合。从数据结构角度来看,Python列表时一个可变长度顺序储存结构...
  • 它允许⽤户⽅便从⼀个集合过滤元素,形成列表,在传递参数过程还可以修改元素。形式如下: [expr for val in collection if condition] 它等同于下⾯for循环: result = [] for val in collection: if ...
  • Python中元组(tuple),列表(list)字典(dict),字符串(str)都是经常用到,它们遍历之间相互转换在使用也非常重要,下面进行相关总结: # 列表集合(去重) list1 = [6, 7, 7, 8, 8, 9] ...
  • python 字典列表相互转换与排序

    千次阅读 2019-09-25 16:49:58
    列表 元组 字典 集合的区别 列表:清单可重复,类型可不同 list 元组: 类似列表不可修改类型 tuple 集合:就是我们数学学的集合应用是去重 set 字典:字典存储键值对数据价值是查询,通过键,查找值 dict 列表 列表...
  • Python的内置数据类型,是一个元素有序集合 一个列表中的数据类型可以不相同 列表中的每个数据称为元素 1.创建列表列表名=[元素1,元素2] list1 = ['Google', 'Runoob', 1997, 2000] 2.访问列表列表名...
  • 集合的创建 # coding:utf-8 num_set = set() # 创建空集合 ...集合其他类型之间的转换 集合转换为列表 # coding:utf-8 a_set = {'1', '2', '3'} print(a_set, type(a_set)) a_list = list(a_set) ...
  • Python 中的列表推导式

    2018-04-21 15:11:41
    本质上可以把列表推导式理解成一种集合了变换筛选功能函数,通过这个函数把一个列表转换成另一个列表。注意是另一个新列表,原列表保持不变。看示例:对a每个元素求立方求a偶数元素立方 求a大于5偶数...
  • python中的listset,np.array之间的转换

    千次阅读 2020-03-15 21:34:33
    集合的性质: 无序性,集合的元素没有先后顺序之分,因此比较两个集合是否相等,就看两者的元素是否一致,不考虑他们的排列顺序 互异性:没有重复的元素 确定性:一个元素在不在集合是可以判断的 ''' 求一个...
  • 相邻元素是不相邻元素中的一种特殊存在,所以我们先来探讨不相邻相同元素删除。 不相邻元素删除 结果:list=[1,2,3,4] #第一种 ...# 第二种 集合可以去重 先转换集合转换列表 list = [1.
  • 集合(set)、列表(list)元组(tuple)间可以相互转换 二.列表去重 原列表:a = [11,22,33,44,11,22,33] 在没有学过集合的时候,我们一般会采用循环判断的方式给列表去重: a = [11,22,33,44,11,22,33] b=[] for i in ...
  • 交集对于给定两个集合A 集合B 交集是指含有所有既属于 A 又属于 B 元素,而没有其他元素的集合叫交集了,下面给出几个python列表交集例子供大家参考。 方法1 遍历b1,如果某个元素同时也存在于b2,则返回...
  • 上一篇文章:Python中的字节bytes+列表lists 本片目录元组tuple元组的介绍元组的创建元组与列表相同的操作元组中不允许的操作元组与列表之间的转换字典dict集合set下一篇文章 元组tuple 元组的介绍 元组也是序列结构...
  • 利用推导式,可以很方便集合中过滤元素形成新的列表, expr for val in collection if condition 例子,集合推导列表 #推导式 #集合转换列表 a={"daniel","nba","chris","sfe","hr"} b=[my.upper() ...
  • 一、列表、元组字符串共同点 1.都可以通过索引得到每一个元素 2.默认索引值总是从0开始 3.可以通过分片方法得到一个范围内元素的集合 4有很多共同操作符(重复、拼接、成员关系操作符) 二、列表、元组...
  • Python列表和元祖

    2017-08-17 17:33:00
    Python的数据结构有 序列容器(容器包含序列、映射、集合Python包含6种内建序列:列表、元祖、字符串、Unicode字符串、buffer对象、xrange对象。 最基本数据结构是序列(元祖和列表),序列所有元素都...
  • python列表

    2020-09-23 20:23:05
    列表Python中最基本数据结构,列表是最常用Python数据类型,列表是一个数据的集合集合内可以放任何数据类型,可对集合方便增删改查操作。Python已经内置确定序列长度以及确定最大最小元素方法 一...
  • python数据结构之集合

    2017-08-30 21:25:21
    集合set思维导图: 集合的引入: python的set其他语言类似, 是一个无序不重复元素集, 基本功能包括关系测试消除重复...当要去除列表中的重复元素时,可将他们转换成集合,然后再转化成列表集合的定义 集合的
  • 因为索引会跟着改变(我们可以将需要删除想保存到人外一个列表中,然后在删除) 删除姓周姓名 lst = ["周杰伦", "周润发", "周星星", "马化腾", "周树人"] # 删除掉姓周信息 del...
  • 2、集合的交互关系 集合去重,交集、并集 交集: 集合1.intersection(集合2) 集合1 & 集合2 并集: 集合1.union(集合2) 集合1 | 集合2 差集: 集合1.difference(集合2),仅取出集合1里...
  • Python的列表推导式

    千次阅读 2016-08-12 20:07:18
    本质上可以把列表推导式理解成一种集合了变换筛选功能函数,通过这个函数把一个列表转换成另一个列表。注意是另一个新列表,原列表保持不变。看示例:(1)对列表中的每项元素进行立方运算(变换功能)a = [1, 2...
  • Set 集合Set是一个无序而且不重复元素集合。下面看看他有哪些基本功能创建集合>>>s1={11,22} s2=set() s3=set([11,22,33,4]) ...{11,22}set(){33,11,4,22}把列表转换集合,注意列表中重复元素只保留...
  • Python基础六(集合、函数)集合集合简介集合的运算可变类型与不可变类型函数1. 函数简介2. 函数的参数2.1 形参实参2.2 函数的...可以通过set()来将序列字典转换成集合(字典转换集合的时候,取的是字典的键ke

空空如也

空空如也

1 2 3 4 5 ... 16
收藏数 315
精华内容 126
关键字:

python中列表和集合的转换

python 订阅