精华内容
下载资源
问答
  • python列表,元组,集合,字典之间互相转换本文着重介绍python 列表(list),元组(tuple),集合(set),字典(dict)四种类型之间的相互转换,转换成python列表需要使用list函数,转成元组需要使用tuple函数,转成集合...

    python列表,元组,集合,字典之间互相转换

    本文着重介绍python 列表(list),元组(tuple),集合(set),字典(dict)四种类型之间的相互转换,转换成python列表需要使用list函数,转成元组需要使用tuple函数,转成集合需要使用set函数,转成字典需要使用dict函数

    1. 内置函数list

    内置函数list可以将字符串,集合,元组转换为列表

    a = "python" # 字符串

    b = {1, 2, 3} # 集合

    c = (1, 2, 3) # 元组

    print(list(a))

    print(list(b))

    print(list(c))

    输出结果是

    ["p", "y", "t", "h", "o", "n"]

    [1, 2, 3]

    [1, 2, 3]

    list函数能否将字典转换成列表呢,这个需要探索一下

    print(list({"a": 3, "b": 5}))

    输出结果为

    ["a", "b"]

    使用list函数转换字典,得到的是字典里所有的key,并没有获得value

    2. 内置函数set

    set函数可以将字符串,列表转换成集合

    a = "python" # 字符串

    b = [1, 2, 1, 2] # 列表

    c = {"a": 1, "b": 2} # 字典

    d = (1, 2, 3, 4) # 元组

    print(set(a))

    print(set(b))

    print(set(c))

    print(set(d))

    程序输出结果

    {"t", "o", "n", "p", "h", "y"}

    {1, 2}

    {"b", "a"}

    {1, 2, 3, 4}

    尝试转换字典时,只能获得由字典的key组成的集合

    3. 内置函数tuple

    a = "python" # 字符串

    b = [1, 2, 1, 2] # 列表

    c = {"a": 1, "b": 2} # 字典

    d = {1, 2, 3, 4} # 集合

    print(tuple(a))

    print(tuple(b))

    print(tuple(c))

    print(tuple(d))

    程序输出结果

    ("p", "y", "t", "h", "o", "n")

    (1, 2, 1, 2)

    ("a", "b")

    (1, 2, 3, 4)

    尝试将字典转换为元组时,只能得到由字典的key组成的元组,看来字典有些特殊

    4. 内置函数dict

    无法直接使用dict函数将列表,元组,集合转换成字典,这是由字典的结构决定的,字典里的元素永远以key-value对的形式存在,key-value是一个映射关系,知道key,便可以获得value,而其他3种容器类型数据不存在映射关系,因此无法转换。

    dict函数有自己特殊的使用方法

    my_dict = dict(a=1, b=2)

    print(my_dict)

    程序输出结果

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

    展开全文
  • str操作 join() 把列表变成字符串 split() 把字符串转换成列表 3. list的删除问题(绕) 列表在循环的时候如果执行了删除操作. 索引和长度会有变化. 这种删除是不安全. 先把要删除的内容放在一个新列表中. 然后循环这...

    1. for循环的问题.

    2. str操作
    join() 把列表变成字符串
    split() 把字符串转换成列表
    3. list的删除问题(绕)
    列表在循环的时候如果执行了删除操作. 索引和长度会有变化. 这种删除是不安全.
    先把要删除的内容放在一个新列表中. 然后循环这个新列表. 删除老列表.

    dict在循环过程中是不允许删除的.
    把要删除的键放在列表中. 循环列表删除字典

    4. set集合
    无序的. 不重复的. 内容必须是可哈希的数据类型.
    本身是不可哈希
    添加:add(),update(),
    删除:pop()
    查询:可迭代对象

    需要可哈希的时候用frozenset()
    5. 深浅拷贝
    拷贝是复制一份
    浅拷贝: 只会拷贝第一层内容. 第二层的内容不会拷贝
    1. copy() 2.[:]
    深拷贝: 拷贝所有内容. 包括里层的所有内容

     

    下面是详细内容

    for 循环增加了解

    for 循环架构

    for .....

    else:

       代码块

    这里和while是一样的,如果循环正常结束的话,那么执行else的代码,如果是通过break跳出的话,不执行else的.

    示例如下:

    s = "abcdefg"
    for w in s:
        print(w)
        if w == "f":
            break
    else:
        print("哈哈")
    
    """
    执行结果如下:
    a
    b
    c
    d
    e
    f
    """

     

    str 操作 (join方法)

    join方法主要是列表生成字符串的操作,把列表所有内容迭代用左边的字符连起来.

    具体方法是"边接字符".join(迭代对像)

    这里要注意只有是字符连接,不能是整数.处理的值是迭代对像都可以.

    示例如下:

    s = ["1","2","3","4","5"]
    s2 = "_".join(s)
    print(s2)
    """
    执行结果如下:
    1_2_3_4_5
    """

    列表转成字符串,可以通过下面来转

    lst = ["a","b","c"]

    s = "".join(lst)

     

     list的删除问题

    介绍:列表如下删除有两个错误,是因为列表在删除的过程中列表的索引和长度发生了变化,所以产生的结果也不同

    示例:

    lst = ["水浒","红楼","西游","三国"]
    for w in lst:
        lst.remove(w)
    print(lst)
    
    
    """
    生成的结果却并不是空的,而是下面这个值
    ['红楼', '三国']
    """

    这个的原因是w在for里面每次是增加的,通过增加后找相应索引位置的值.

    当我们删除第1个索引的值后,列表发生变化,向左移动一下.原来第二位置的值变成了第一个索引.所以删除会隔着删除.索引是不断增加的,增加后在变化后的列表中找到对应的值,找不到就退出

    同时的这样的示例也会出错

    lst = ["水浒","红楼","西游","三国","孙悟空","孙行者","lkjjlj","kjlkjljlkj"]
    # for w in lst:
    #     lst.remove(w)
    # print(lst)
    for w in range(0,len(lst)):
        del lst[w]
    print(lst)
    
    """
    这样写的话,会报下面的错误:
    Traceback (most recent call last):
      File "D:/python/测试.py", line 32, in <module>
        del lst[w]
    IndexError: list assignment index out of range
    
    """

    原理大致也是因为按索引删除后,后面的列表没有这个索引了,会报错的.

    正确的写法如下:

    lst = ["水浒","红楼","西游","三国","孙悟空","孙行者","lkjjlj","kjlkjljlkj"]
    # for w in lst:
    #     lst.remove(w)
    # print(lst)
    # for w in range(0,len(lst)):
    #     del lst[w]
    # print(lst)
    lst2 = lst.copy()
    for w in lst2:
        lst.remove(w)
    print(lst)
    
    """
    结果是正确的空列表
    """

     

    另外一个重要的知识点是字典在循环的过程中是不能删除的.如下示例

    dic = {"a":"好人","b":"坏人"}
    for w in dic:
        dic.pop(w)
    print(dic)
    
    """
    会报以下错误
    Traceback (most recent call last):
      File "D:/python/测试.py", line 39, in <module>
        for w in dic:
    RuntimeError: dictionary changed size during iteration
    """

    如果想删除只能和列表一样,单独存一个列表,循环这个列表删除,参考示例如下:

    dic = {"a":"好人","b":"坏人"}
    # for w in dic:
    #     dic.pop(w)
    # print(dic)
    
    lst = []
    for w in dic.keys():
        lst.append(w)
    for w in lst:
        dic.pop(w)
    print(dic)

     

     

    dict中的fromkey(),可以帮我们通过list来创建⼀一个dict

    示例:

    dic = dict.fromkeys(["a","b","c"],["d","e"])
    print(dic)
    """
    输出结果是
    {'a': ['d', 'e'], 'b': ['d', 'e'], 'c': ['d', 'e']}
    """

    这个dist.fromkey主要是把第一个值迭代当成key,第二个值当作value传给字典.

    这里有一个坑 ,这个value传给key时,传的是同一个内存地址,如果发生变化,值都会变.如下示例:

    dic = dict.fromkeys(["a","b","c"],["d","e"])
    dic["a"].append("哈哈")
    print(dic)
    """
    {'a': ['d', 'e', '哈哈'], 'b': ['d', 'e', '哈哈'], 'c': ['d', 'e', '哈哈']}
    """

    可以看到上面结果都有"哈哈"可实际上我只修改了第一个key的值.

    同时也要注意,dict.fromkey并不是在原字典上作修改,而是生成字典,

     

    示例如下:

    dic = {}
    dic2 = dic.fromkeys("ab","cd")
    print(dic)
    print(dic2)
    """
    {}
    {'a': 'cd', 'b': 'cd'}
    """

     

     

     

    类型转换:

    列表转元组   list ----> tuple(lst)

    元组转list     tu ----> list(tu)

    示例:

    lis = ["1","2","3"]
    tu = tuple(lis)
    print(lis)
    print(tu)

    列表转成str 是通过join(列表)

    str转成列表可以通过split和extend

     

     

    集合

     集合有三个方面,一个是无序的,一个是去重的,一个是元素是可hash的(也就是不可变的),但是集合本身是不可hash的,也就是可变的.集合可以理解成字典的key的组合.

    set也用{}表示.

    根据如上特性,可以做如下测试:

    set1 = {1,2,3,[]}
    print(set1)
    
    """
    运行后会报如下错误
        set1 = {1,2,3,[]}
    TypeError: unhashable type: 'list'
    
    """

    也可以做去重测试.

    set1 = {1,2,3,1}
    print(set1)
    """
    运行以后报如下错误
    {1, 2, 3}
    """

     

    这里有一个重要应用,列表去重.如下:

    lst = [1,4,3,8,0,3,2,5,1]
    set1 = set(lst)
    print(set1)
    lst = list(set1)
    print(lst)

     

     

     

    set集合增删改查

    增是通过add和update来增加的.(update是迭代更新的)

    s.add("增加的值")###重复的内容不不会被添加到set集合中

    集合的初始化可以通过这个来初始化

     

    s = set()
    
    s.add("我的值")
    
    print(s)

    s.update()迭代update里面的内容传和集合当中

    示例如下:

    s = set()
    
    s.update("abc")
    print(s)
    s.update(["","",""])
    print(s)

     

    删除

    删除有三个操作s.pop()随机删除.s.clear()清空集合.s.remove()删除某个具体的元素.

    示例如下:

    s = set()
    s.update("abcdef")
    item = s.pop()
    print(s)
    print(item)
    s.remove("b")
    print(s)
    s.clear()
    print(s)

    这里注意两点,如果remove删除的元素不存在的话,会报错的.另外一个空集合并不是{}而是set()

     

    集合的改就是先删除,后添加

     

    for循环来查,示例如下:

    s = set()
    s.update("abcdef")
    for w in s:
        print(w)

     

    集合的常⽤操作

    集合的操作有交集和并集,以及差集,其他暂时 不做了解.

    示例如下:

    s = set()
    s.update("abcdef")
    s2 = set()
    s2.update("bdljlj")
    print(s2)
    print(s)
    print(s-s2)  #差集
    print(s & s2)  #交集
    print(s | s2)  #并集

     

    深浅copy

    如果是赋值的话,两个变量用的是一个内存地址.如果你想用两个内存地址的话,需要用到copy这个东西,示例如下:

    lst = []
    lst.extend("abcdefg")
    print(lst)
    lst1 = lst
    print(id(lst),id(lst1))  #两个内存地址是一样的.
    lst1 = lst.copy()  #如果想获取两个不同的内存地址的话,可以用浅copy.
    print(id(lst),id(lst1)) 

    这个copy使用是使用.lst.copy()方法来实现的.但是这个会有个问题.比如如下:

    lst = []
    lst.extend("abcdefg")
    lst.append(["中文","英文"])
    lst1 = lst.copy()  #如果想获取两个不同的内存地址的话,可以用浅copy.
    print(lst)
    print(lst1)
    lst1[-1].append("外文")
    print(lst)   # 浅copy的问题是对于列表中的列表再修改的话,是会有问题的.因为浅copy只是copy了列表的内存地址
    print(lst1)

    原因就是浅copy只是copy的列表等可变元素的内存地址.解决办法就是用深copy

    深copy的使用方法是

    import copy 

    lst1 = copy.deepcopy(lst)

    示例:

    import  copy
    
    lst = []
    lst.extend("abcdefg")
    lst.append(["中文","英文"])
    lst1 = copy.deepcopy(lst)
    print(lst)
    print(lst1)
    lst1[-1].append("外文")
    print(lst)   # 深copy无论里面,无论几层,都会重新copy的.当然会浪费一点内存
    print(lst1)

     

    转载于:https://www.cnblogs.com/ahliucong/p/9150927.html

    展开全文
  • ls = [“p”,“p”,“y”,“y”,123] #添加原始列表 nls = set(ls) #列表转换成"集合“,集合的特点:不存在重复元素 print(nls) ls = list(nls) #集合转换成列表 print(ls) ...

    ls = [“p”,“p”,“y”,“y”,123] #添加原始列表
    nls = set(ls) #列表转换成"集合“,集合的特点:不存在重复元素
    print(nls)
    ls = list(nls) #集合转换成列表
    print(ls)

    展开全文
  • list1 = [1, 2, 3, 4, 5, 6, 6, 6] tuple1 = (11, 22, 33, 44, 55, 66) ...# 将列表以及集合转换成元组 list1_2_tuple = tuple(list1) set1_2_tuple = tuple(set1) print(list1_2_tuple) print(...
    list1 = [1, 2, 3, 4, 5, 6, 6, 6]
    tuple1 = (11, 22, 33, 44, 55, 66)
    set1 = {'a', 'b', 'c', 'd', 'e'}
    
    # 将列表以及集合转换成元组
    list1_2_tuple = tuple(list1)
    set1_2_tuple = tuple(set1)
    print(list1_2_tuple)
    print(set1_2_tuple)  # 因为集合是无序的,所以当转换成元组时,其输出与原来可能不同
    
    # 将元组以及集合转换成列表
    tuple1_2_list = list(tuple1)
    set1_2_list = list(set1)
    print(tuple1_2_list)
    print(set1_2_list)  # 集合还有唯一性,具有去重功能,能快速完成列表去重,同一集合中输出的元素不能相同
    
    # 将列表以及元组转换成集合
    print(set(list1))
    print(set(tuple1))
    

    运行结果如下所示:

    (1, 2, 3, 4, 5, 6, 6, 6)
    ('d', 'a', 'e', 'c', 'b')
    [11, 22, 33, 44, 55, 66]
    ['d', 'a', 'e', 'c', 'b']
    {1, 2, 3, 4, 5, 6}
    {33, 66, 11, 44, 22, 55}
    
    Process finished with exit code 0

     

    展开全文
  • Python 集合

    2017-03-02 09:18:53
    Python集合 set集合是无序的集合,会合并重复的值。 1、集合定义 set()生成Set无序集合 >>> set('hello') # set将字符串转换成字符集合 set(['h', 'e', 'l', 'o']) >>> set([1, 2, 3, 4]) # 列表转换成集合 set([1...
  • python集合相关

    2020-02-09 22:10:20
    集合是无序的。 元组转换为集合列表转换成集合: 字典转换集合:只取第一个Key
  • #TODO 怎么去{}中的数据 t=[5,6,7,9,'a','h'] s=set(t) ss=list(s) print(t,s,ss) #TODO:python基本常识:列表集合...# nls = set(ls) #列表转换成"集合“,集合的特点:不存在重复元素 # print(nls) # ls = list...
  • Python集合

    2016-01-14 09:15:35
    集合的创建和删除set()函数将列表、元组等其他可迭代对象转换成集合,会去除重复元素仅保留一个。>>> aSet = {3,5} >>> aSet.add(7) >>> print(type(aSet),aSet) <class 'set'> {3, 5, 7}>>> bSet = set(range
  • 本文主要介绍列表,元组,字典,集合以及和字符串之间的相互转换。...# 将元组转换成列表 tu = (1, 2, 3) li = list(tu) print(li, type(li)) # 打印结果:[1, 2, 3] <class 'list'> \2. 列表与字符串的互换.
  • 列表集合和字典推导式 列表推导式是Python最受喜爱的特性之⼀。它允许⽤户⽅便的从⼀个集合过滤元素,形成列表,在传递参数的过程中还可以修改元素。形式如下: ...下的字符串,并将其转换成⼤写: In [15
  • Python集合与函数

    2020-04-24 19:52:52
    集合&函数初识1.集合1.1 集合简介1.2 集合的使用1.3 集合的运算2. 函数简介3. 函数的参数3.1 形参和实参3.2 函数的传递方式4. 不定长参数5....1.集合 1.1 集合简介 ...可以通过set()来将序列和字典转换成...
  • Python元祖,列表,字典,集合的比较    定义 方法 列表 可以包含不同类型的对象,可以增减元素,可以跟其他的列表结合或者把一个列表拆分, 用[ ]来定义的 eg:aList=[123,'abc',...
  • 字典在转换成列表后只保留“key”部分。 字符串在转换成列表后将每个字符保留在[]中,用逗号隔开 优先掌握的操作: #1、按索引存取值(正向存取+反向存取):即可存也可以取(同时可以改值) name=[‘egon’,’...
  • 前言:对于刚接触Python的新鸟来说,数据之间的转换特别蛋疼,今天我就来说一下,列表、字典、json之间的转换,也就是说集合转换成json,json转换成集合,以及列表和字典之间的关系。
  • Python基础(三)Python容器:列表、元组、字典和集合 本文是我在学习期间的笔记,看的书是《python语言及其应用》。...list() 将其他类型转换成列表 [offset] 获取元素 包含列表的列表 使用 offset...
  • Python容器:列表、元组、字典与集合 列表:  1....  使用[ ] 或者 list()创建列表:empty_list = [ ]... 使用list()将其他数据类型转换成列表 方括号[ ]列表 圆括号( )元组  >>> list('cat')  ...
  • 列表推导是一个将一个列表(实际上是任意可迭代对象)转换成另一个列表的工具。在转换时,每个元素都可以按照某个条件被包含在新的列表中,并根据需要做出一些变换。先看一例子,比如我想把某列表中的每项值都乘以2#...
  • Python-集合

    2020-09-30 18:02:18
    集合 Python 中set与dict类似,也是一组key的集合,但不存储value。由于key不能重复,所以,在set中...使用set(value)工厂函数,把列表或元组转换成集合集合的两个特点:无序 (unordered) 和唯一 (unique)。 由于
  • 第3章 Python容器:列表、元组、字典与集合...3.2.2 使用list()将其他数据类型转换成列表将一个字符串转换成由单个字母组成的列表:>>> list('cat') ['c', 'a', 't']将一个元组转换成列表:>>> a_tuple = ('i','am','fi
  • python:集合&函数一、集合1、集合的简介2、集合的使用3、集合的运算二、可变类型和不可变类型三...可以通过set()来将序列和字典转换成集合 总结一下: 集合的最大特点是:集合里边的元素是不可重复的并且集合内的
  • 1.list(str):将str转换成list类型,str可以使字符串也可以是元组类型 2.aList.append(‘test’):追加元素到列表中去 3.del aList[1]:删除列表中下标为1的元素 del aList:删除整个列表 4.cmp(list1,list2):比较两个...
  • 定义 方法 列表 ...可以包含不同类型的对象,可以增减元素,可以跟其他的列表结合或者把一个列表...1.list(str):将str转换成list类型,str可以使字符串也可以是元组类型 2.aList.append('test'):追加元素到列...
  • Python元祖,列表,字典,集合的比较 定义 方法 列表可以包含不同类型的对象,可以增减元素,可以跟其他的...将str转换成list类型,str可以使字符串也可以是元组类型 2.aList.append('test'):追加元素到列表中去...
  • python列表推导式、字典推导式、集合推导式python列表推导式、字典推导式、集合推导式列表推导式生成list格式示例一:输出为==表达式==示例二:输出为==函数(有返回值)==生成generator字典推导式示例一:把字典中的...
  • 可以通过set()来将序列和字典转换成集合 set.len() 来获取集合中元素的数量 set.add() 像集合中添加元素 set.update() 将一个集合中的元素添加到另一个集合当中 set.pop() 随机删除集合中的一个元素一般是删除最后一...
  • 一 转成列表 #数组==》集合 lst=list((1,2,3,4)); print(lst) #map--》集合 lst2=list({"name":"liu","age:":12}.items()); print(lst2) 结果为: [1, 2, 3, 4] [('name', 'liu'), ('age:', 12)] 二 转成数组...
  • list comprehension/dict comprehension/set comprehension/generator comprehension列表解析式是将一个列表(实际上适用于任何可迭代对象(iterable))转换成另一个列表的工具。在转换过程中,可以指定元素必须...
  • python 容器类型转换

    2020-07-20 20:46:09
    tuple() :将某个序列转换成元组 list() :将某个序列列转换成列列表 set() :将某个序列列转换成集合 注意 1. 集合可以快速完成列表去重 2. 集合不支持下标 list1 = [10, 20, 30, 20, 40,...# list():转换成列表 prin
  • Python基础之集合

    2021-05-03 16:27:10
    1集合的声明与修改 # python基础之集合 ...# python集合的类型为set 我们也可以通过set将元组和列表转换成集合 print(type(name1)) print(type(set((1, 2, 3, 4)))) # 集合的添加与删除 name1.add('李四') # 向集合

空空如也

空空如也

1 2 3 4 5 ... 15
收藏数 287
精华内容 114
关键字:

python集合转换成列表

python 订阅