精华内容
下载资源
问答
  • python 字典

    2021-01-02 15:42:43
    列表、元组和字符串属于序列类型,元素有前后次序,可以通过编号位置的索引来访问元素。而字典python中唯一的映射类型。键值对的无序可变序列。 定义字典时,每个元组的键和值用冒号分隔,相邻元素用逗号分隔,...

    python 字典

    列表、元组和字符串属于序列类型,元素有前后次序,可以通过编号位置的索引来访问元素。而字典是python中唯一的映射类型。键值对的无序可变序列。
    定义字典时,每个元组的键和值用冒号分隔,相邻元素用逗号分隔,所有元组放在一堆大括号中。键不能重复,但值可以。一个键只能对应一个值,但多个键可以对应相同的值。

    一、字典常用操作

    1.字典的创建

    1.使用“=”将一个字典赋给一个变量。

    >>>a_dict={'Alice':95,'Beth':82,'Tom':65.5,'Emily':82}
    >>>a_dict
    {'Alice':95,'Beth':82,'Tom':65.5,'Emily':82}
    

    也可以创建一个空字典

    >>>b_dict={}
    >>>b_dict
    {}
    

    2.使用内建函数dict( ),通过其他映射或(键,值)这样的序列对建立字典。

    #以映射函数方式建立字典,zip( )函数返回tuple列表
    >>>c_dict=dict(zip(['one','two','three'],[1,2,3]))
    >>>c_dict
    {'three':3,'two':2,'one':1}
    >>>d_dict=dict(one=1,two=2,three=3)       #以键值对方式建立字典
    >>>d_dict
    {'three':3,'two':2,'one':1}
    >>>e_dict=dict([('one',1),('two',2),('three',3)])      #以键值对形式的列表建立字典
    >>>e_dict
    {'three':3,'two':2,'one':1}
    >>>f_dict=dict((('one',1),('two',2),('three',3)))      #以键值对形式的元组建立字典
    >>>f_dict
    {'three':3,'two':2,'one':1}
    >>>g_dict=dict( )          #创建空字典
    >>>g_dict
    { }
    

    3.通过内建函数fromkeys( )来创建字典。
    一般形式:dict.fromkeys(seq[,value])
    sqe表示键值列表;value可选参数,用于设置键序列(sqe)的值。

    >>>h_dict={}.fromkeys((1,2,3),student)           #指定value值为‘student’
    >>>h_dict
    {1:'student',2:'student',3:'student'}
    >>>i_dict={}.fromkeys((1,2,3))
    >>>>i_dict
    {1:None,2:None,3:None}
    >>>j_dict={}.fromkeys(())          #创建空字典
    >>.j_dict
    {}
    

    2.字典元素的读取

    1.使用下标的方式。字典的下标是键,若使用的键不存在,则提示异常错误。

    >>>a_dict={'Alice':95,'Beth':82,'Tom':65.5,'Emily':82}
    >>>a_dict['Tom']
    65.5
    >>> a_dict[95]
    Traceback (most recent call last):
      File "<pyshell#1>", line 1, in <module>
        a_dict[95]
    KeyError: 95
    

    2.使用字典对象的get()方法获取指定键对应的值。
    dict.get(key, default=None)

    >>>a_dict.get('Alice')
    95
    >>>a_dict.get('a','address')             #若键不存在,返回指定值'address'
    ‘address'
    >>>a_dict.get('a')
    >>>print(a_dict.get('a'))
    None
    

    3.字典元素的添加与修改

    1.字典没有预定义大小的限制,可以随时添加新的键值对,或者修改现有键所关联的值。添加与修改的方式相同,都是“字典变量名[键名]=键值”的形式。区分添加和修改,看键名与字典中的键名是否有重复。存在表修改,不存在表添加

    >>>a_dict['Beth']=79          #修改键为'Beth'的值
    >>.a_dict
    {'Alice':95,'Beth':79,'Tom':65.5,'Emily':82}
    >>>a_dict['Eric']=98          #增加元素
    >>>a_dict
    {'Alice':95,'Beth':79,'Tom':65.5,'Emily':82,'Eric':98}
    

    2。使用字典对象update()的方法将另一个字典的键值对一次性全部添加到当前字典对象,如果当前字典对象存在着相同的键,则另一个字典中的值为准对象当前字典进行更新。

    >>>a_dict={'Alice':95,'Beth':79,'Tom':65.5,'Emily':95}
    >>>b_dict={'Eric':98,'Tom':82}
    >>>a_dict.update(b_dict)
    >>>a_dict
    {'Alice':95,'Beth':79,'Tom':82,'Emily':95,'Eric':98}
    

    4.删除字典中的元素

    1.使用del命令删除字典中指定键对应的元素。

    >>>del a_dict['Beth']
    >>>a_dict
    {'Alice':95,'Tom':65.5,'Emily':95,'Eric':98}
    >>> del a_dict[82]
    Traceback (most recent call last):
      File "<pyshell#5>", line 1, in <module>
        del a_dict[82]
    KeyError: 82
    

    2.使用字典对象的pop()方法删除字典元素并返回指定键的元素

    >>>a_dict.pop('Alice')
    95
    >>>a_dict
    {'Tom':65.5,'Emily':95,'Eric':98}
    

    3.使用字典对象的popitem()的方法。由于字典是无序的,删除的是一个随机元素

    >>>a_dict.popitem()
    {'Emily':95}
    >>>a_dict
    {'Tom':65.5,'Eric':98}
    

    4.使用字典对象的clear()方法删除字典的所有元素

    >>>a_dict.clear()
    >>>a_dict
    {}
    

    5.删除字典

    使用del命令删除字典

    >>> del a_dict
    >>> a_dict
    Traceback (most recent call last):
      File "<pyshell#7>", line 1, in <module>
        a_dict
    NameError: name 'a_dict' is not defined
    

    二、字典的遍历

    1.遍历字典的关键字

    使用字典的keys()方法,以列表的方式返回字典的所有键。
    dict.keys()

    >>>a_dict={'Alice':95,'Beth':79,'Tom':65.5,'Emily':95}
    >>>a_dict.keys()
    dict_keys(['Alice','Beth','Tom','Emily'])
    

    2.遍历字典的

    使用字典对象的values()方法,以列表的方式返回字典的所有值。
    dict.values()

    a_dict.values()
    dict_values([65.5,95,79,95])
    

    3.遍历字典的元素

    使用字典的items()方法,以列表的方式返回字典的所有(键,值)元素。
    dict.items()

    >>>a_dict.items()
    dict_items([('Alice', 95), ('Beth', 79), ('Tom', 65.5), ('Emily', 95)])
    

    三、字典应用举例

    1.字典键值对调

    a_dict={'a':1,'b':2,'c':3}
    b_dict={}
    for key in a_dict:
        b_dict[a_dict[key]]=key
    print(b_dict)
    
    
    {1: 'a', 2: 'b', 3: 'c'}
    

    2.统计单词出现次数

    string=input("input string:")
    string_list=string.split()
    word_dict={}
    for word in string_list:
    	if word in word_dict:	
    		word_dict[word]+=1
    	else:
    		word_dict[word]=1
    print(word_dict)
    
    
    input string:to be or not to be
    {'to': 2, 'be': 2, 'or': 1, 'not': 1}
    
    展开全文
  • Python-集合、序列字典的分析 1.集合 集合元素不可更改,不能是可变数据类型 集合是多个元素的无序组合,{ },建立可用{}或者set(),建立空集合,必须使用set() 集合见操作:交&amp;、并|、补^、差- 属于...

                                 Python-集合、序列、字典的分析

    1.集合

    集合元素不可更改,不能是可变数据类型

    集合是多个元素的无序组合,{ },建立可用{}或者set(),建立空集合,必须使用set()

    集合见操作:交&、并|、补^、差- 属于、不属于(<=、<、>=、>)

    判断元素是否在集合中;数据去重

    A = {"py", 123, ("py", 123)}  # {"py", 123, ("py", 123)}#
    B = set("pypy123")  # {'p', '2', 'y', '3', '1'}
    C = {"py", 123, "py", 123}  # {123, 'py'}
    print(A | B)
    print(A - B)
    print(A & B)
    print(A ^ B)
    A ^= B
    print(A)
    print(A >= B)
    
    #output
    {'2', '3', 'p', ('py', 123), 'py', 'y', '1', 123}
    {123, 'py', ('py', 123)}
    set()
    {('py', 123), 'py', 'y', '2', '1', '3', 'p', 123}
    {('py', 123), 'py', 'y', '2', '1', '3', 'p', 123}
    True

    在了解了基础之后,这里列举了一些其他的函数::

    #  S.add(x)增加x到S中
    #  S.discard(x)移除x
    #  S.remove(x)移除x,若没有x则报错KeyError
    #  S.clear()移除所以元素
    #  S.pop()随机返回一个元素,并更新S,若S为空则报错KeyError
    #  S.copy返回一个S
    #  len(S)返回S中元素的个数
    #  x in S判断x是否在S中
    #  x not in S判断x是否不在S中
    #  set(x)将x转变为集合

    2.序列

    序列是具有先后关系的一组元素

     是一维元素向量,元素类型可以不同,用序号引导(0开始) 

    序列是一个基类类型,包括字符串类型、元组类型、列表类型

     序号包括正向递增序号和反向递减序号 # 数据表示-》元素遍历----主要用处

    元组类型---数据保护

    # x in S判断x是否在S中
    # x not S判断x是否不在S中
    # s + t连接两个序列s和t
    # s * n 或 n * s将序列s复制n次
    # s[j]索引
    # s[i:j] 或 s[i: j: k]切片(k步长)
    # len(S)返回S中元素的个数
    # min(S)/max(S)返回序列S中最小(大)元素,需要可比较
    # S.index(x)/S.index(x,i,j)返回序列S从i到j位置中第一次出现x的位置
    # S.count(x)统计x出现的次数
    

    *元组::

    元组一旦被创建就不能被修改

     用()或者tuple()创建

    接下来先看一些元组的例子::

    create = "cat", "dog", "tiger"
    print(create)
    print(create[::-1])
    color = (0x001100, create)
    print(color)
    print(color[-1][2][0])
    
    #output
    
    ('cat', 'dog', 'tiger')
    ('tiger', 'dog', 'cat')
    (4352, ('cat', 'dog', 'tiger'))
    t

    *列表::

    列表创建后可以别随意修改

    使用[]或者list()创建

    接下来先看一些列表的例子::

    lr = ["cat", "dog", "tiger", 1024]
    lt = lr  # 单纯=表示引用
    lt[0] = "python"  # lt[i:j:k]=lt
    print(lr)
    # del ls[i]/del ls[i:j:k]删除
    # ls += lt将lt增加到ls中去
    # ls *= n将ls重复n次
    lr[1:2] = [1, 2, 3, 4]
    print(lr)
    del lr[::3]
    print(lr)
    print(lr * 2)
    print(lr)
    
    #output
    
    ['python', 'dog', 'tiger', 1024]
    ['python', 1, 2, 3, 4, 'tiger', 1024]
    [1, 2, 4, 'tiger']
    [1, 2, 4, 'tiger', 1, 2, 4, 'tiger']
    [1, 2, 4, 'tiger']

    在了解了基础之后,这里列举了一些其他的函数::

    # ls.append(x)再最后增加一个元素
    # ls.clear()删除所以元素
    # ls.copy()返回一个S
    # ls.insert(i, x)在第i个位置插入一个x
    # ls.pop(i)将第i个位置的元素取出并删除
    # ls.remove(x)删除第一个出现的x
    # ls.reverse()元素反转
    lr.append(123)
    print(lr)
    lr.insert(3, "human")
    print(lr)
    lr.reverse()
    print(lr)
    
    #output
    
    [1, 2, 4, 'tiger', 123]
    [1, 2, 4, 'human', 'tiger', 123]
    [123, 'tiger', 'human', 4, 2, 1]

     

    3.字典

    字典是键值对的集合,键值对之间无序

    采用大括号{}和dict()创建,键值对用冒号:表示

     键<>:<>值

    接下来先看一些列表的例子::

    # del d[k]删除
    # k in d 判断是否存在
    # d.keys()返回字典d中所有的键信息
    # d.values()返回字典d中所有的值信息
    # d.items()返回字典d中所有的键值对信息
    d = {"中国": "北京", "美国": "华盛顿", "法国": "巴黎"}
    print("中国" in d)
    print(d.keys())  # 可遍历
    print(d.values())
    
    #output
    
    True
    dict_keys(['中国', '美国', '法国'])
    dict_values(['北京', '华盛顿', '巴黎'])

    在了解了基础之后,这里列举了一些其他的函数::

    # d.get(k, <default>)键k存在,则返回相应值,不存在则返回<default>值
    # d.pop(k, <default>)键k存在,则取出相应值,不存在则返回<default>值
    # d.popitem()随机取出一个键值对,以元组形式返回
    # d.clear()删除所有元素
    # len(d)返回d中元素的个数
    # d["2"] = 2新增元素  d[key]

     

    展开全文
  • Python 字典

    2017-07-03 22:14:00
    Python 字典 1、字典可以看作是无序的...3、属于可变映射类型(key-value),但不支持序列操作(合并,分片)。 4、字典基本操作 In [1]: D={'001':'egg','002':'apple','003':'orange','004':'banana','000...

    Python 字典

    1、字典可以看作是无序的列表集合,字典是通过键来存取,而不是通过偏移来存取。

    2、任意对象的无序集合,可变长、异构、任意嵌套。

    3、属于可变映射类型(key-value),但不支持序列操作(合并,分片)。

    4、字典基本操作

    In [1]: D={'001':'egg','002':'apple','003':'orange','004':'banana','000':'minion'}
    
    In [2]: D['002']
    Out[2]: 'apple'
    
    In [3]: D
    Out[3]:
    {'000': 'minion',
     '001': 'egg',
     '002': 'apple',
     '003': 'orange',
     '004': 'banana'}
    
    In [4]: len(D)
    Out[4]: 5
    
    In [5]: 'orange' in D
    Out[5]: False
    
    In [6]: 'apple' in D
    Out[6]: False
    
    In [7]: '001' in D
    Out[7]: True
    
    In [9]: list(D.keys())
    Out[9]: ['001', '002', '003', '004', '000']
    
    In [10]: D['003']=['good orange','bad orange']
    
    In [11]: D
    Out[11]:
    {'000': 'minion',
     '001': 'egg',
     '002': 'apple',
     '003': ['good orange', 'bad orange'],
     '004': 'banana'}
    
    In [12]: del D['000']
    
    In [13]: D
    Out[13]:
    {'001': 'egg',
     '002': 'apple',
     '003': ['good orange', 'bad orange'],
     '004': 'banana'}
    
    In [14]: D['000']='minion'
    
    In [15]: D
    Out[15]:
    {'000': 'minion',
     '001': 'egg',
     '002': 'apple',
     '003': ['good orange', 'bad orange'],
     '004': 'banana'}

     

    转载于:https://www.cnblogs.com/matplot/p/7113312.html

    展开全文
  • Python字典dict

    2019-11-22 12:20:40
    字典是许多数据的集合,属于可变序列类型,它是无序的可变序列,其保存的内容是以“键值对”的形式存放的。 Python 中,字典的数据类型为 dict,通过 type() 函数即可查看。 字典类型所具有的主要特征: (1)...

    字典是许多数据的集合,属于可变序列类型,它是无序的可变序列,其保存的内容是以“键值对”的形式存放的。

    Python 中,字典的数据类型为 dict,通过 type() 函数即可查看。

    字典类型所具有的主要特征:

    (1)通过键而不是通过索引来读取元素。

    (2)字典是任意数据类型的无序集合。

    (3)字典是可变的,并且可以任意嵌套。

    (4)字典中的键必须唯一。

    (5)字典中的键必须不可变,因此只能使用数字、字符串或者元组,不能使用列表。

    ======创建字典======

    1.赋值创建

    Python 字典类型的语法格式如下:

    dictname = {'key':'value1','key2':'value2',...,'keyn':valuen}

    其中 dictname 表示字典类型名,keyn : valuen 表示各个元素的键值对。需要注意的是,同一字典中各个元素的键值必须唯一。

    示例:

    adict = {'a':1,'b':2,'c':3}
    print(adict)
    bdict = {}
    print(bdict)
    cdict = {(1,2):'good','bad':[1,2]}
    print(cdict)

    结果:

    {'a': 1, 'b': 2, 'c': 3}
    {}
    {(1, 2): 'good', 'bad': [1, 2]}

    2.通过fromkeys()方法创建

    Python 中,还可以使用 dict 字典类型提供的 fromkeys() 方法创建所有键值为空的字典,使用此方法的语法格式为:

    dictname = dict.fromkeys(list,value=None)

    其中,list 参数表示字典中所有键的列表,value 参数默认为 None,表示所有键对应的值。此种创建方式,通常用于初始化字典,设置 value 的默认值。

    示例:

    ddict = {"a":1,'b':2}
    edict = dict.fromkeys(ddict)
    print(edict)

    结果:

    {'a': None, 'b': None}
     

    3.通过dict()映射函数创建

    fdict = dict(a=1,b=2,c=3)      #使用此方式创建字典时,字符串不能带引号
    print(fdict)
    gdict = [['a',1],['b',2]]    #向 dict() 函数传入列表或元组,其中元素是包含 2 个元素的列表或元组,其中第一个为键,第二个为值。
    print(dict(gdict))
    hdict =[(1,2),(3,4),(5,6)]
    print(dict(hdict))
    idict =((1,2),(3,4),(5,6))
    print(dict(idict))
    jdict =([1,2],[3,4],[5,6])
    print(dict(jdict))
    akeys = ['a','b','c']   #通过dict() 函数和 zip() 函数可将前两个列表转换为对应的字典。akeys和avalues还可以是字符串或元组
    avalues = [1,2,3]
    print(dict(zip(akeys,avalues)))

    结果:

    {'a': 1, 'b': 2, 'c': 3}
    {'a': 1, 'b': 2}
    {1: 2, 3: 4, 5: 6}
    {1: 2, 3: 4, 5: 6}
    {1: 2, 3: 4, 5: 6}
    {'a': 1, 'b': 2, 'c': 3}

    注意,无论采用以上哪种方式创建字典,字典中各元素的键都只能是字符串、元组或数字,不能是列表。

    ====访问字典=====

    1.通过键来访问

    akeys = ['a','b','c']
    avalues = [1,2,3]
    adict = dict(zip(akeys,avalues))
    print(adict['c'])

    结果:

    3

    2.通过get() 方法获取指定键的值

    get() 方法的语法格式为:

    dict.get(key[,default])

    其中,dict 指的是所创建的字典名称;key 表示指定的键;default 用于指定要查询的键不存在时,此方法返回的默认值,如果不手动指定,会返回 None。

    示例:

    adict = dict(a=1,b=2,c=3)
    print(adict.get('a'))

    print(adict.get('d'))   #指定的键不存在,会返回None
    print(adict.get('e','No this key'))   #指定的键不存在,但会返回一个提示信息

    结果:

    1
    None
    No this key

    =====删除字典=====

    和删除列表、元组一样,手动删除字典也可以使用 del 语句。

    adict = dict(a=1,b=2,c=3)

    del(adict)
    print(adict)

    结果:

    NameError: name 'adict' is not defined

    ====添加键值对====

    如果要为 dict 添加键值对,只需为不存在的 key 赋值即可。实现此操作的语法格式如下:

    dictname[key] = value

    示例 :

    adict = {}
    adict['a'] = 1
    adict['b'] = 2
    adict['c'] = 3
    print(adict)

    结果:

    {'a': 1, 'b': 2, 'c': 3}

    =====修改键值对========

    “修改键值对”并不是同时修改某一键值对的键和值,而只是修改某一键值对中的值。

    由于在字典中,各元素的键必须是唯一的,因此,如果新添加元素的键与已存在元素的键相同,原来键所对应的值就会被新的值替换掉。例如:

    adict = dict(a=1,b=2,c=3)

    adict['a'] = 111
    print(adict)

    结果:

    {'a': 111, 'b': 2, 'c': 3}

    ====删除键值对======

    如果要删除字典中的键值对,还是可以使用 del 语句。例如:

    adict = dict(a=1,b=2,c=3)

    del adict['c']
    print(adict)

    结果:

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

    ====判断键值对是否存在======

    如果要判断字典中是否存在指定键值对,首先应判断字典中是否有对应的键。判断字典是否包含指定键值对的键,可以使用 in 或 not in 运算符。对于 dict 而言,in 或 not in 运算符都是基于 key 来判断的。

    adict = dict(a=1,b=2,c=3)

    print('a' in adict)
    print('a' not in adict)

    结果:

    True
    False

    ====键值对操作方法======

    1.keys()、values() 和 items()方法

    这 3 个方法之所以放在一起介绍,是因为它们都用来获取字典中的特定数据。keys() 方法用于返回字典中的所有键;values() 方法用于返回字典中所有键对应的值;items() 用于返回字典中所有的键值对。

    adict = dict(a=1,b=2,c=3)

    print(adict.keys())
    print(adict.values())
    print(adict.items())

    结果:

    dict_keys(['a', 'b', 'c'])
    dict_values([1, 2, 3])
    dict_items([('a', 1), ('b', 2), ('c', 3)])

    注意:在 Python 2.x 中,这三个方法的返回值是列表类型。但在 Python 3 中,并不是列表和元组类型,因为 Python 3不希望用户直接操作这几个方法的返回值。如果想使用返回的数据,有以下 2 种方法:

    (1)使用 list() 函数,将它们返回的数据转换成列表,例如:

    adict = dict(a=1,b=2,c=3)

    print(list(adict.keys()))
    print(list(adict.values()))
    print(list(adict.items()))

    结果:

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

    (2)利用多重赋值的技巧,利用循环结构将键或值分别赋给不同的变量,例如:

    adict = dict(a=1,b=2,c=3)
    for i in adict.keys():
        print(i,end= ' ')
    print()
    for j in adict.values():
        print(j,end=' ')
    print()
    for k,v in adict.items():
        print("key:%s"% k,"value:%s"% v)

    结果:

    a b c 
    1 2 3 
    key:a value:1
    key:b value:2
    key:c value:3

    2.copy()方法

    copy() 方法用于返回一个具有相同键值对的新字典,例如:

    adict = dict(a=1,b=2,c=3)

    cdict = adict.copy()
    print(cdict)

    结果:

    {'a': 1, 'b': 2, 'c': 3}

    注意,copy() 方法所遵循的拷贝原理,既有深拷贝,也有浅拷贝。拿拷贝字典 a 为例,copy() 方法只会对最表层的键值对进行深拷贝,也就是说,它会再申请一块内存用来存放 {'one': 1, 'two': 2, 'three': []};而对于某些列表类型的值来说,此方法对其做的是浅拷贝,也就是说,b 中的 [1,2,3] 的值不是自己独有,而是和 a 共有。

    a = {'a':1,'b':2,'c':[1,2,3]}
    b = a.copy()
    a['a'] = 111
    print(a)
    print(b)
    a['d'] = 4
    print(a)
    print(b)
    a['c'].remove(1)
    print(a)
    print(b)

    结果:

    {'a': 111, 'b': 2, 'c': [1, 2, 3]}
    {'a': 1, 'b': 2, 'c': [1, 2, 3]}
    {'a': 111, 'b': 2, 'c': [1, 2, 3], 'd': 4}
    {'a': 1, 'b': 2, 'c': [1, 2, 3]}
    {'a': 111, 'b': 2, 'c': [2, 3], 'd': 4}
    {'a': 1, 'b': 2, 'c': [2, 3]}

    从运行结果不难看出,对 a 增加新键值对,b 不变;而修改 a 某键值对中列表内的元素,b也会相应改变。

    3.update()方法

    在执行 update() 方法时,如果被更新的字典中己包含对应的键值对,那么原 value 会被覆盖;如果被更新的字典中不包含对应的键值对,则该键值对被添加进去。

    a = {'a':1,'b':2,'c':[1,2,3]}
    a.update({'a':111,'b':222,'e':444})
    print(a)

    结果:

    {'a': 111, 'b': 222, 'c': [1, 2, 3], 'e': 444}

    4.pop()方法

    pop() 方法用于获取指定 key 对应的 value,并删除这个键值对。

    a = {'a':1,'b':2,'c':[1,2,3]}

    a.pop('a')
    print(a)

    结果:

    {'b': 222, 'c': [1, 2, 3]}

    5.popitem()方法

    popitem() 方法用于随机弹出字典中的一个键值对。

    注意,此处的随机其实是假的,它和 list.pop() 方法一样,也是弹出字典中最后一个键值对。但由于字典存储键值对的顺序是不可知的,因此 popitem() 方法总是弹出底层存储的最后一个键值对。

    a = {'a':1,'b':2,'c':[1,2,3]}
    print(a)
    k,v = a.popitem()   #将弹出项的key赋值给k、value赋值给v
    print(k,v)

    结果:

    {'a': 1, 'b': 2, 'c': [1, 2, 3]}
    c [1, 2, 3]

    6.setdefault()方法

    setdefault() 方法总能返回指定 key 对应的 value;如果该键值对存在,则直接返回该 key 对应的 value;如果该键值对不存在,则先为该 key 设置默认的 value,然后再返回该 key 对应的 value。

    a = {'a':1,'b':2,'c':[1,2,3]}
    print(a)
    print(a.setdefault('a',444))  #键存在,则不会修改value
    print(a.setdefault('e',444))  #键不存在,则新增键值对
    print(a)

    结果:

    {'a': 1, 'b': 2, 'c': [1, 2, 3]}
    1
    444
    {'a': 1, 'b': 2, 'c': [1, 2, 3], 'e': 444}

    ====使用字典格式化字符串=======

    temp = 'name:%(name)s,price:%(price)d,'
    book = {'name':'python','price':120}
    print(temp % book)

    结果:

    name:python,price:120

     

    展开全文
  • `mapping` 对象会将 `hashable` 值映射到任意对象。 映射属于可变对象。 目前仅有一种标准映射类型`字典`。...Python 字典(dict)是一种无序的、可变的序列,元素以“键值对(key-value)”的形式存储。
  • 除了字典和集合属于无序序列之外,列表、元组、字符串等序列都支持双向索引。 注意,序列的第一个元素下标都是“0”。(和C语言中数组一样) 还有,就是Python竟然可以用“负数”作为序列下标!最后一个元素下标为...
  • python中的字典

    2020-05-16 23:08:44
    字典属于无序序列,元素存放无序,是通过哈希方式进行数据存取的,字典是一个可变容器,字典中保存一个个的键值对: key : value。我们通过key来获取对应的值,很类似我们的汉语字典。 字典中键必须是唯一的,必须...
  • Python dict字典详解

    2019-08-13 17:21:43
    和列表相同,字典也是许多数据的集合,属于可变序列类型。不同之处在于,它是无序的可变序列,其保存的内容是以“键值对”的形式存放的。 字典类型是 Python中唯一的映射类型。“映射”是数学中的术语,简单理解,它...
  • python dict 字典详解

    2019-10-03 10:21:51
    和列表相同,字典也是许多数据的集合,属于可变序列类型。不同之处在于,它是无序的可变序列,其保存的内容是以“键值对”的形式存放的。 字典中,习惯将各元素对应的索引称为键(key),各个键对应的元素称为值...
  • 目录 序列是什么 序列的分类 序列的通用操作 检查成员(判断值是否属于序列) ...序列是Python中最基本的数据结构。序列中的每个元素都分配一个数字 - 它的位置,或索引,第一个... 无序序列字典、集合、控制...
  • (三)python语法之序列

    2018-09-28 21:59:29
    其中字典和集合都是无序序列。 元组 元祖的创建与删除 元组的创建很简单,直接赋值()就可以了,但是,需要注意一些细节,当创建的元组只有一个元素的时候,需要在这个元素后面加上一个逗号.x=(1,)元组的删除比较...
  • 字典,集合,序列

    2020-07-24 15:34:57
    字典Python 唯一的一个 映射类型,字符串、元组、列表属于序列类型。 使用 hash(X),只要不报错,证明 X 可被哈希,即不可变,反过来不可被哈希,即可变。 a = 1 hash(1),hash('1'),hash(a),hash([1,2,3]) ----...
  • 许多应用中要利用关键词查找对应信息例如通过学号来检索某学生的信息其中通过学号查找所对应学生的信息的方式称为映射Python语言的字典(dictionary)类型就是一种映射字典及后面将要提到的集合中的数据元素之间没有...
  • 数据结构可以说是相互之间存在一种或者多种特定...无序序列字典、集合、(range、Zip、map、enumerate等) 其中,列表、字典、集合又属于可变序列,其余属于不可变序列 序列是Python中最基本的数据结构。列表元组字符...
  • 字典Python 唯一的一个 映射类型,字符串、元组、列表属于序列类型。 字典的定义 字典无序的 键:值(key:value)对集合,键必须是互不相同的(在同一个字典之内)。 dict 内部存放的顺序和 key 放入的顺序是...
  • Python学习之2.6dict字典

    2020-05-28 11:00:18
    字典可包含很多个key和很多个value,也属于集合类型,但不是序列无序)。 字典的定义方式为:{key1:value1,key2:value2…},一个字典中不能有两个重复的key,如下: >>> {1:1,2:2,3:3} {1: 1, 2: 2, 3...
  • 字典和集合属于无序序列之外,列表、元组、字符串等序列类型均支持双向索引,第一个元素下标为0,第二个元素下表为1,以此类推;如果使用负数作为索引,则最后一个元素下表为-1,倒数第二个元素下表为-2...
  • 1. 属于可变序列 2. 可变长度 3. 任意类型 4. 任意嵌套 5. 支持原位改变 定义字典 none_dict = {} #定义一个空字典 user_info_dict = {"name":"马小跳","age":17,"...
  • 其中,列表、元组、字符串都属于序列(有序性),字典属于映射(通过键映射值),而集合(set)是一种无序、自动去重的数据结构。本篇总结了列表、元组、字典和集合的常用内置方法,翻译难免有误,以英文为准 ...
  • Python有关字典

    千次阅读 2014-05-09 23:14:47
    Python中的字典是完全不同的东西,它们不是序列,没有顺序,只是一种映射。内部的元素以逗号分开,以大括 号包围。它们不是通过位置而是通过键来存储的,也具有可变性,可以就地的改变,增大或减小。   主要属性...
  • 其中,列表、元组、字符串都属于序列(有序性),字典属于映射(通过键映射值),而集合(set)是一种无序、自动去重的数据结构。本篇总结了列表、元组、字典和集合,字符串方法请参照上一篇 一、列表 python...
  • Python第二章

    2021-03-21 20:36:00
    字典和集合属于无序序列之外,列表、元组、字符串等序列类型均支持双向索引,第一个元素下标为0,第二个元素下标为1,以此类推;如果使用复数作为索引,则最后一个元素下标为-1,倒数第二个元素下标为-2,以此类推...
  • python2.0

    2021-03-21 17:10:44
    1.索引:除字典和集合属于无序序列外,列表,元组,字符串,等序列类型均支持双向索引。 2。本章主要介绍几种基本数据类型的用法,以及通过实际应用来介绍列表的推导式,切片操作和生成器的推导式。 3.列表是python的...
  • 序列是一块用来存放多个值的内存空间,Python中常用的序列结构有列表、元组、字典、字符串、集合等,除字典和集合属于无序序列之外,列表、元组、字符串等类型都支持双向索引。 2.分类 2.1 列表 定义:列表是...
  • python学习心得

    2021-03-28 22:48:47
    列表,字符串,元祖属于有序序列,支持双向索引,支持使用附属数作为下标来访问... 字典和集合属于无序序列,集合不支持使用下标的方式来访问其中的元素,可以使用字典的“键”作为下标来访问字典中的“值”。 ...
  • Python一周小记(六)

    2021-05-05 18:58:58
    字典,集合属于无序序列 列表,元组,字符串是有序序列,支持双向索引(从左往右查找[ 1: ],从右往左查找([ :-1]) 列表的一些要点 列表中元素的类型 同一个列表中元素的类型可以不相同,可以同时包含整数、实数、...
  • 字典

    2018-11-06 20:15:49
    任意对象的无序集合:键提供了字典中项的象征性(而非物理性)位置,不支持序列操作(无序) 可变长,异构,任意嵌套:可在原处增长或缩短 属于可变映射类型:字典是唯一内置的映射类型 对象引用表(散列表): ...

空空如也

空空如也

1 2 3
收藏数 46
精华内容 18
关键字:

python字典属于无序序列

python 订阅