精华内容
下载资源
问答
  • 不过要注意,这里的元素,是一对键(key)和(value)相比于列表和元组,字典的性能更优,特别是对于查找、添加和删除,字典都能在常数的时间复杂度内完成而集合和字典基本相同,唯一的区别,就是集合没有键和的配对...

    @Author :Runsen Python字典和元组总结

    字典是一系列无序元素的组合,其长度大小可变,元素可以任意地删减和改变。不过要注意,这里的元素,是一对键(key)和值(value)

    相比于列表和元组,字典的性能更优,特别是对于查找、添加和删除,字典都能在常数的时间复杂度内完成

    而集合和字典基本相同,唯一的区别,就是集合没有键和值的配对是一系列无序的、唯一的元素组合。

    d1 = {'name': 'jason', 'age': 20, 'gender': 'male'}

    d2 = dict({'name': 'jason', 'age': 20, 'gender': 'male'})

    d3 = dict([('name', 'jason'), ('age', 20), ('gender', 'male')])

    d4 = dict(name='jason', age=20, gender='male')

    d1 == d2 == d3 ==d4

    True

    s1 = {1, 2, 3}

    s2 = Set([1, 2, 3])

    s1 == s2

    True

    集合并不支持索引操作,因为集合本质上是一个哈希表,和列表不一样

    s = {1, 2, 3}

    s[0]

    Traceback (most recent call last):

    File "", line 1, in

    TypeError: 'set' object does not support indexing

    想要判断一个元素在不在字典或集合内,我们可以用 value in dict/set

    s = {1, 2, 3}

    1 in s

    True

    10 in s

    False

    d = {'name': 'Runsen', 'age': 20}

    'name' in d

    True

    'location' in d

    False

    字典的增删改

    In [1]: d = {'name': 'Runsen', 'age': 20}^M

    ...:

    In [2]: d['gender'] = 'male'

    In [3]: d['birthday'] = '1999-10-01'

    In [4]: d

    Out[4]: {'name': 'Runsen', 'age': 20, 'gender': 'male', 'birthday': '1999-10-01'}

    In [5]: d['birthday'] = '1999/10/01'

    In [6]: d.pop('birthday')

    Out[6]: '1999/10/01'

    In [8]: d

    Out[8]: {'name': 'Runsen', 'age': 20, 'gender': 'male'}

    In [9]: s = {1, 2, 3}^M

    ...:

    In [10]: s.add(4)

    In [11]: s

    Out[11]: {1, 2, 3, 4}

    In [12]: s.remove(4)

    In [13]: s

    Out[13]: {1, 2, 3}****

    字典的升序和降序排序

    d = {'b': 1, 'a': 2, 'c': 10}

    d_sorted_by_key = sorted(d.items(), key=lambda x: x[0]) # 根据字典键的升序排序

    d_sorted_by_value = sorted(d.items(), key=lambda x: x[1]) # 根据字典值的升序排序

    d_sorted_by_key

    [('a', 2), ('b', 1), ('c', 10)]

    d_sorted_by_value

    [('b', 1), ('a', 2), ('c', 10)]

    字典和集合性能

    字典和集合是进行过性能高度优化的数据结构,特别是对于查找、添加和删除操作

    列表的做法

    # list version

    def find_unique_price_using_list(products):

    unique_price_list = []

    for _, price in products: # A

    if price not in unique_price_list: #B

    unique_price_list.append(price)

    return len(unique_price_list)

    # products id 和 price

    products = [

    (143121312, 100),

    (432314553, 30),

    (32421912367, 150),

    (937153201, 30)

    ]

    print('number of unique price is: {}'.format(find_unique_price_using_list(products)))

    # 输出

    number of unique price is: 3

    集合的做法

    #set version

    def find_unique_price_using_set(products):

    unique_price_set = set()

    for _, price in products:

    unique_price_set.add(price)

    return len(unique_price_set)

    products = [

    (143121312, 100),

    (432314553, 30),

    (32421912367, 150),

    (937153201, 30)

    ]

    print('number of unique price is: {}'.format(find_unique_price_using_set(products)))

    # 输出

    number of unique price is: 3

    比较运行的时间,也就是性能

    import time

    id = [x for x in range(0, 100000)]

    price = [x for x in range(200000, 300000)]

    products = list(zip(id, price))

    # 计算列表版本的时间

    start_using_list = time.perf_counter()

    find_unique_price_using_list(products)

    end_using_list = time.perf_counter()

    print("time elapse using list: {}".format(end_using_list - start_using_list))

    ## 输出

    time elapse using list: 41.61519479751587

    # 计算集合版本的时间

    start_using_set = time.perf_counter()

    find_unique_price_using_set(products)

    end_using_set = time.perf_counter()

    print("time elapse using set: {}".format(end_using_set - start_using_set))

    # 输出

    time elapse using set: 0.008238077163696289

    在性能上集合完爆列表

    字典和集合都是无序的数据结构,其内部的哈希表存储结构,保证了查找,插入,删除操作的高效性。所以,字典和集合通常运用在对元素的查找,去重

    初始化字典的方式有两种方法,比较下哪一种更高效,

    In [20]: timeit a ={'name':"runsen",'age':20}

    127 ns ± 0.8 ns per loop (mean ± std. dev. of 7 runs, 10000000 loops each)

    In [21]: timeit b =dict({'name':"runsen",'age':20})

    438 ns ± 3.41 ns per loop (mean ± std. dev. of 7 runs, 1000000 loops each)

    第一种,因为不用调用相关的函数

    字典的键可以是一个列表吗?下面这段代码中,字典的初始化是否正确

    In [22]: d = {'name': 'Runsen', ['education']: [' primary school', 'junior middle school']}^M

    ...:

    ---------------------------------------------------------------------------

    TypeError Traceback (most recent call last)

    in

    ----> 1 d = {'name': 'Runsen', ['education']: [' primary school', 'junior middle school']}

    TypeError: unhashable type: 'list'

    In [23]: d = {'name': 'Runsen', ('education'): [' primary school', 'junior middle school']}^M

    ...:

    ...:

    In [24]: d

    Out[24]: {'name': 'Runsen', 'education': [' primary school', 'junior middle school']}

    用列表作为 Key 在这里是不被允许的,因为列表是一个动态变化的数据结构,字典当中的 key 要求是不可变的,原因也很好理解.

    key 首先是不重复的,如果 Key 是可以变化的话,那么随着 Key 的变化,这里就有可能就会有重复的 Key,那么这就和字典的定义相违背;如果把这里的列表换成之前我们讲过的元组是可以的,因为元组不可变。

    展开全文
  • 1、列表可以作为集合元素吗? 2、集合可以作为列表元素吗? 3、元组可以作为集合元素吗? 4、集合可以作为元组元素吗? 5、字典可以作为集合元素吗? 对于上面这五个问题,是不是不太懂呢?接下来我会一一...

    1、列表可以作为集合的元素吗?

    2、集合可以作为列表的元素吗?

    3、元组可以作为集合的元素吗?

    4、集合可以作为元组的元素吗?

    5、字典可以作为集合的元素吗?

    对于上面这五个问题,是不是不太懂呢?接下来我会一一解答。

    一、第一个问题:

    首先我们需要知道什么可以作为集合的元素。集合对象是一组无序排列***可哈希***的值,集合成员可以做字典中的键。那么可哈希与不可哈希是什么意思呢?

    简要的说可哈希的数据类型,即不可变的数据结构(字符串str、元组tuple、对象集objects);同理,不可哈希的数据类型,即可变的数据结构 (集合set,列表list,字典dict)

    >>> set1={[1,2,3,4],4,5,6}c
    Traceback (most recent call last):
      File "<pyshell#0>", line 1, in <module>
        set1={[1,2,3,4],4,5,6}
    TypeError: unhashable type: 'list'
    

    注:unhashable是“不可哈希的”的意思

    可见,报错了。所以列表不可以作为集合的元素.

    二、第二个问题:

    那么列表的元素可以有哪些呢?列表没有长度限制,元素类型可以不同,使用非常灵活。看例子:

    >>> list1=[{1,2,3,4},4,5,6]
    >>> list1
    [{1, 2, 3, 4}, 4, 5, 6]
    >>>
    

    说明集合可以作为列表的元素。

    三、第三个问题:

    在第一个小问中说到,元组(tuple)是不可变的数据结构(可哈希的数据类型),因此,是可以作为集合元素的。

    >>> set2={(1,2,3,4,5),6,7,8}
    >>> set2
    {8, (1, 2, 3, 4, 5), 6, 7}
    >>> 
    

    四、第四个问题:

    元组与列表类似,不同之处在于元组的元素不能修改具体用法我这里不在赘述。

    >>> tuple1=({1,2,3,4,5},89,5)
    >>> tuple1
    ({1, 2, 3, 4, 5}, 89, 5)
    >>> 
    

    所以集合可以作为元组的元素。

    五、第五个问题:

    因为字典是可变的数据结构(不可哈希),所以自然也不能作为集合的元素。

    >>> set1={{'Name': 'Runoob', 'Age': 7, 'Class': 'First'},4,5,6}
    Traceback (most recent call last):
      File "<pyshell#0>", line 1, in <module>
        set1={{'Name': 'Runoob', 'Age': 7, 'Class': 'First'},4,5,6}
    TypeError: unhashable type: 'dict'
    >>> 
    

    附上一张表:

    在这里插入图片描述
    观看顺序:ex:字符串可以作为列表的元素 列表可以作为列表的元素…

    如果有错误的地方,还请指正,大家一起学习。

    展开全文
  • 我想使用如下字典:示例:{[8,16]:[[1,2,4,8],8],[16,24]:...使用setdefault,我可以字典中创建值列表,但不能为键创建列表以下是我代码:#!/usr/bin/env python"""This Program calculates common factors betw...

    我想使用如下字典:

    示例:{[8,16]:[[1,2,4,8],8],[16,24]:[[1,2,3,4,8,12],12]}

    8和16是将要输入的两个数字,我需要构建如上所述的字典.

    使用setdefault,我可以在字典中创建值列表,但不能为键创建列表

    以下是我的代码:

    #!/usr/bin/env python

    """

    This Program calculates common factors between two Numbers , which

    is stored on a list and also greatest common factor is also computed.

    All this is stored in a dictionary

    Example: { '[n1, n2]': [[Commonfac1(n1,n2), Commonfac2(n1,n2)....Commonfacn(n1,n2)],GreatestCommonFactor] }

    """

    def Factors(number):

    result = []

    for i in range(1, number+1):

    if (number % i) == 0:

    result.append(i)

    return result

    def Common_Factors(n1, n2):

    result = []

    for element in n1:

    if element in n2:

    result.append(element)

    return result

    def greatest_common_factor(common_factors):

    count = 0

    length = len(common_factors)

    current_largest = common_factors[count]

    for i in common_factors:

    count += 1

    if count <= length -1:

    if current_largest < common_factors[count]:

    current_largest = common_factors[count]

    return current_largest

    def main():

    n1 = 8

    n2 = 16

    result1 = Factors(n1)

    result2 = Factors(n2)

    CF = Common_Factors(result1, result2)

    GCF = greatest_common_factor(CF)

    dict = {}

    dict.setdefault([n1, n2], []).append(CF)

    print dict

    if __name__ == '__main__':

    main()

    当我运行上面的程序时,我得到以下错误:

    $python math74.py

    Traceback (most recent call last):

    File "math74.py", line 58, in

    main()

    File "math74.py", line 54, in main

    dict.setdefault([n1, n2], []).append(CF)

    TypeError: unhashable type: 'list'

    关于我如何实现上述任何提示. ?

    澄清更多:

    {[8,16]:[[1,2,4,8],8],[16,24]:[[1,2,3,4,8,12],12]}

    8,16是两个数字,它们是用户输入,1,2,4,8是常见因子,8是最大公因数.

    展开全文
  • 时候,给定了一个列表,我们需要交替使用列表元素作为键和对应来创建字典,比如下面一个列表 &gt;&gt;&gt; lst = ['Jerry', 20, 'Alice', 30, 'Wendy', 40] 我们需要将第一个作为键,第二...

    有的时候,给定了一个列表,我们需要交替使用列表中的元素作为键和对应值来创建字典,比如下面一个列表

    >>> lst = ['Jerry', 20, 'Alice', 30, 'Wendy', 40]

    我们需要将第一个作为键,第二个作为值,依次类推,可以这样:

    >>> lst = ['Jerry', 20, 'Alice', 30, 'Wendy', 40]
    >>>
    >>> def dict_from_list(lst):
    ...     return dict(zip(lst[::2], lst[1::2]))
    ...
    >>> dict_from_list(lst)
    {'Jerry': 20, 'Wendy': 40, 'Alice': 30}
    >>>

     

    展开全文
  • 可以使用itertools.groupby,首先对字典使用.items(),然后根据键第一个元素对该列表进行排序,并使用键作为第一个元素(第一个元素第一个元素)使用itertools.groupby关键元组,).然后,对于每个组,您可以...
  • 数据框是一种二维数据结构,其中数据以表格格式存储,以行和列形式。它可以可视化为SQL数据表或excel工作表表示...字典列表可以作为输入传递到数据框。默认情况下,字典键被用作列名。让我们看一个例子-示例imp...
  • #字典的一键多值print'方案一 list作为dict的值 值允许重复'd1={}key=1value=2d1.setdefault(key,[]).append(value)value=2d1.setdefault(key,[]).append(value)print d1#获取值print '方案一 获取值'print list(d1...
  • Python列表,元组,字典的区别: 1、元组是不可变的, 而列表、字典是可变的。元组是不可变对象,对象一旦生成,它的值将不能更改;...3、列表不能作为字典的key值,而元组可以。字典的键是唯一
  • 列表和元组是Python中最常用的两种数据结构,字典是第三种。 相同点: ...我们可以修改列表的值,但是不修改元组的值。 由于列表是可变的,我们不能将列表用作字典中的key。 但可以使用元组作为字典key...
  • 两个列表合并成字典

    千次阅读 2017-08-12 10:23:12
    如果你是两个列表的值变成都变成字典的值那你需要自己一个列表写一个键名的列表。先把两个列表合并,两个列表有两种合并方法。 第一种用循环。 第二种直接用extend()函数 不能将两个列表直接用append()函数...
  • 方法二:从Python 2.2 版本起,可以使用一个工厂方法,传入一个元素是列表的元组作为参数方法三:从Python 2.3 版本起, 可以用一个很方便的内建方法fromkeys() 来创建一个"默认"字典, 字典中元素具有相同的值 ...
  • 如何根据字典的键或来排序

    万次阅读 2016-07-24 18:26:04
    字典的值可以是任何对象类型(字典甚至可以嵌入另一个字典中),键可以为任何可hash的对象,也就是它不可以被改变(所以字符串并不是唯一合法的键,但是可变的比如列表就绝对不能作为键)。不像Python的列表或者元组...
  • 例如 >>a = {'a':1, 'b':2, 'c':3} >>b = a.items() ([('a', 1), ('b', 2), ('c', 3)]) ...然后对其使用operator.itemgetter(i)函数可以选定键或者值作为排序依据,i = 0表示按键大小排序 i=1表示按大小排序
  • 在具体学习 列表、元组、字典 之前,我们需要先知道: Python 中包含 6 个序列(sequence)内置类型,即 列表、元组、字符串、...列表是最常用Python数据类型,它可以作为一个方括号内逗号分隔出现。...
  • 列表列表是Python中最基本数据结构。列表每个元素都分配一个数字 - 它位置,或索引,第一个索引是0,第二个索引是1,依此类推...列表是最常用Python数据类型,它可以作为一个方括号内逗号分隔出现。列...
  • 注:只能用不可变的对象(例如字符串)来作为字典的键,  语法:dic={key1:value1, key2:value2, key3:value3},键和用冒号(:)分割,各个对用逗号(,)分割。 注:字典中的键/对是没有顺序的。如果想要一个.....
  • 生成器推导式创建元组:,生成器... 元组特点:1、不可变序列 2、元组的访问和处理速度比列表快 3、与整数和字符串一样,元组可以作为字典的键,列表永远不能作为字典的键使用。 字典:“键值对”包含键对象和对象...
  • 列表是最常用Python数据类型,它可以作为一个方括号内逗号分隔出现。 创建一个列表,只要把逗号分隔不同数据项使用方括号括起来即可例如: List1{“goole”,“runoob”,“1997”,“2000”}; 与字符串...
  • 列表与元组 相同点: 列表与元组都是容器,是一系列... 不能把列表当做字典的关键字,因为只有不可变的值才能进行哈希运算,因此只有不可变的值才能作为关键字。要使用列表做关键字,你需要把它转化为元组 ...
  • 元组列表字典

    2015-01-14 00:08:17
    A.rankDict = dict(rank)即可将元组转为字典型A.dict.fromkeys... 将S中的元素作为字典的key,value默认为None,也可以指定一个初始,代码示例:myDict=dict.fromkeys('hello',True)forkinmyDict.keys():print(k,...
  • python 函数返回列表字典 return

    万次阅读 2019-04-01 20:58:27
    特点: 所有函数都有返回值,如果没有 return 语句,会隐式地调用 return None ...函数返回值可以是一个数、列表字典,返回列表字典时该怎么办呢? 返回值是字典,而我们要取字典某个时: def func1...
  • 字典的遍历(1)遍历字典的键(1)遍历字典的值4.字典的修改操作 一、列表 1.定义 列表是由一系列按特定顺序排列的元素组成的,列表可以包含任何的东西加入作为列表的元素,其中的元素之间也可以没有任何的关系,...
  • 1.在Python中字典(类似于Java中的Map)...事实上可以将任何Python中的值作为字典的值。 (1).字典的创建;在Python中,字典用放在花括号{}中的一系列键-值对表示,例如: save={'color':'red','size':'5','se...
  • 列表(list) 使用格式:每个元素使用中括号 [ ] 括起来*斜体样式* 字典(dictionary) 使用格式:字典变量名={键1:1,键2:2,键3:3} ...使用场景:作为参数和返回值,可以接收和返回多个数据 ...
  • 字典Python的字典数据类型是基于hash散列算法实现的,采用键值对(key:value)的形式,根据key的值计算value的地址,具有非常快的查取和... 列表字典、集合等就不可以作为key。同时,同一个字典内的key必须是唯一...
  • 元组(tuple): 固定长度不可变的顺序容器,访问效率高,适合存储一些常量数据,可以作为字典的键使用。 集合(set): 无序,元素只出现一次,可以自动去重。 字典(dict): 长度可变的 hash 字典容器。存储的...
  • extend与append区别:extend : 将被合并集合所有给主动进行合并集合 ,最终结果为两个集合元素个数总和 append: 将被添加集合作为一个整体,list1 元素等于之前个数加1两个列表可以相加 ...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 622
精华内容 248
关键字:

列表可以作为字典的值