精华内容
下载资源
问答
  • python字典包含字典 什么是Python字典? 仅次于Python列表字典或“ dict”在内存中用于存储一系列值(也称为集合)地方。 字典特殊,因为没有使用数字索引按顺序引用值。 而是在字典中, 用用户定义键...

    python字典包含字典

    什么是Python字典?

    仅次于Python列表的字典或“ dict”是在内存中用于存储一系列值(也称为集合)的地方。 字典是特殊的,因为没有使用数字索引按顺序引用值。 而是在字典中, 用用户定义的键来引用值 ,就像物理词典中的单词是与其含义的“值”相关联的“键”一样。 该键通常是一个字符串,但可以是任意数量的数据类型。

    <code class="Python hljs livecodeserver" style="box-sizing: border-box; font-size: 1.75 rem; font-family: &quot;Input Sans Narrow&quot;; color: rgb(51, 51 , 51 ); background: rgb(248, 248 , 248 ); border-radius: 0 px; line-height: 25 px; padding: 0.5 em 16 rem; white-space: pre; font-feature-settings: &quot;zero&quot;; letter-spacing: 0 px; display: block; overflow-x: auto; border-top: 1 px solid rgb(224, 224 , 225 ); border-bottom: 1 px solid rgb(224, 224 , 225 );">my_dict = {<span class="hljs-string" style="box-sizing: border-box; color: rgb(221, 17 , 68 );">'my_key'</span> : <span class="hljs-string" style="box-sizing: border-box; color: rgb(221, 17 , 68 );">'my_value'</span>}</code>

    例如,与其使用my_list [0]引用列表中的第一个值, 不如通过其键引用任何字典元素:

    <code class="Python hljs livecodeserver" style="box-sizing: border-box; font-size: 1.75 rem; font-family: &quot;Input Sans Narrow&quot;; color: rgb(51, 51 , 51 ); background: rgb(248, 248 , 248 ); border-radius: 0 px; line-height: 25 px; padding: 0.5 em 16 rem; white-space: pre; font-feature-settings: &quot;zero&quot;; letter-spacing: 0 px; display: block; overflow-x: auto; border-top: 1 px solid rgb(224, 224 , 225 ); border-bottom: 1 px solid rgb(224, 224 , 225 );"><span class="hljs-meta" style="box-sizing: border-box; color: rgb(153, 153 , 153 ); font-weight: 700 ;">&gt;&gt;&gt; </span>my_dict[<span class="hljs-string" style="box-sizing: border-box; color: rgb(221, 17 , 68 );">'my_key'</span>]
    ‘my_value’</code>

    这些显式引用比列表索引符号更易读,并且在大多数情况下提高了代码的可维护性和性能。

    此外,键值组合允许嵌套数据的复杂层次结构。 由于字典中的单词是其定义值的键,因此字母也可以是单词本身的值的键。 在处理复杂数据时,结构中数据的这种复杂性通常是必需的。 借助此特殊功能,词典可以位于列表和用户定义的类之间。 Python字典比列表具有更多的功能,但是不需要像具有唯一属性和方法的用户定义类那样费力。

    如何创建和引用Python词典

    根据情况,有几种声明字典的方法。 最简单的方法是将键和值括在花括号中,如下所示:

    <codeclass = "Python hljs livecodeserver" style= "box-sizing: border-box; font-size: 1.75rem; font-family: &quot;Input Sans Narrow&quot;; color: rgb(51, 51, 51); background: rgb(248, 248, 248); border-radius: 0px; line-height: 25px; padding: 0.5em 16rem; white-space: pre; font-feature-settings: &quot;zero&quot;; letter-spacing: 0px; display: block; overflow-x: auto; border-top: 1px solid rgb(224, 224, 225); border-bottom: 1px solid rgb(224, 224, 225);" >my_dict = {<span class = "hljs-string" style= "box-sizing: border-box; color: rgb(221, 17, 68);" > 'key1' </span>: <span class = "hljs-number" style= "box-sizing: border-box; color: teal;" > 1 </span>, <span class = "hljs-string" style= "box-sizing: border-box; color: rgb(221, 17, 68);" > 'key2' </span>: <span class = "hljs-number" style= "box-sizing: border-box; color: teal;" > 2 </span>}</code>

    您也可以将键值对传递给dict关键字构造函数,尽管这种情况不太常见:

    <code class="Python hljs livecodeserver" style="box-sizing: border-box; font-size: 1.75 rem; font-family: &quot;Input Sans Narrow&quot;; color: rgb(51, 51 , 51 ); background: rgb(248, 248 , 248 ); border-radius: 0 px; line-height: 25 px; padding: 0.5 em 16 rem; white-space: pre; font-feature-settings: &quot;zero&quot;; letter-spacing: 0 px; display: block; overflow-x: auto; border-top: 1 px solid rgb(224, 224 , 225 ); border-bottom: 1 px solid rgb(224, 224 , 225 );">my_dict = dict(key1 = <span class="hljs-number" style="box-sizing: border-box; color: teal;">1</span>, key2 = <span class="hljs-number" style="box-sizing: border-box; color: teal;">2</span>)</code>

    当返回具有动态值的字典,或者作为lambda或理解的一部分时,在声明中分配值非常有用。 键和值都可以引用其他地方定义的变量,从而可以动态分配。

    有时有必要声明一个空字典,因为稍后可能会添加值,但是与此同时,代码的其他部分也需要引用。

    声明一个空字典:

    <code class="Python hljs livecodeserver" style="box-sizing: border-box; font-size: 1.75 rem; font-family: &quot;Input Sans Narrow&quot;; color: rgb(51, 51 , 51 ); background: rgb(248, 248 , 248 ); border-radius: 0 px; line-height: 25 px; padding: 0.5 em 16 rem; white-space: pre; font-feature-settings: &quot;zero&quot;; letter-spacing: 0 px; display: block; overflow-x: auto; border-top: 1 px solid rgb(224, 224 , 225 ); border-bottom: 1 px solid rgb(224, 224 , 225 );">my_dict = {}
    my_dict = dict()</code>

    值可以在赋值运算符可用时附加到此字典:

    <codeclass = "Python hljs livecodeserver" style= "box-sizing: border-box; font-size: 1.75rem; font-family: &quot;Input Sans Narrow&quot;; color: rgb(51, 51, 51); background: rgb(248, 248, 248); border-radius: 0px; line-height: 25px; padding: 0.5em 16rem; white-space: pre; font-feature-settings: &quot;zero&quot;; letter-spacing: 0px; display: block; overflow-x: auto; border-top: 1px solid rgb(224, 224, 225); border-bottom: 1px solid rgb(224, 224, 225);" >my_dict[<span class = "hljs-string" style= "box-sizing: border-box; color: rgb(221, 17, 68);" > 'key' </span>] = <span class = "hljs-number" style= "box-sizing: border-box; color: teal;" > 123 </span>
    
    <span class = "hljs-meta" style= "box-sizing: border-box; color: rgb(153, 153, 153); font-weight: 700;" >&gt;&gt;&gt; </span>my_dict
    {<span class = "hljs-string" style= "box-sizing: border-box; color: rgb(221, 17, 68);" > 'key' </span>: <span class = "hljs-number" style= "box-sizing: border-box; color: teal;" > 123 </span>}</code>

    Python字典像其他任何变量一样被存储和引用。 实际上,字典可以存储在字典中,而且经常存储在字典中。 在这种情况下,只需像其他任何值一样,通过其键来引用存储的字典。

    <codeclass = "Python hljs livecodeserver" style= "box-sizing: border-box; font-size: 1.75rem; font-family: &quot;Input Sans Narrow&quot;; color: rgb(51, 51, 51); background: rgb(248, 248, 248); border-radius: 0px; line-height: 25px; padding: 0.5em 16rem; white-space: pre; font-feature-settings: &quot;zero&quot;; letter-spacing: 0px; display: block; overflow-x: auto; border-top: 1px solid rgb(224, 224, 225); border-bottom: 1px solid rgb(224, 224, 225);" >my_dict = {
        <span class = "hljs-string" style= "box-sizing: border-box; color: rgb(221, 17, 68);" > 'my_nested_dict' </span>:
            {
                <span class = "hljs-string" style= "box-sizing: border-box; color: rgb(221, 17, 68);" > 'a_key' </span>: <span class = "hljs-string" style= "box-sizing: border-box; color: rgb(221, 17, 68);" > 'a_value' </span>,
                <span class = "hljs-string" style= "box-sizing: border-box; color: rgb(221, 17, 68);" > 'another_key' </span>: <span class = "hljs-string" style= "box-sizing: border-box; color: rgb(221, 17, 68);" > 'another_value' </span>,
            }
    }</code>

    有礼貌地使用空格,以清楚地指示嵌套的层,同时保持与Python最佳实践的一致性。 特定格式可以由IDE自动格式化程序或部署前的lint确定。

    现在,我们可以通过其键引用嵌套字典:

    <code class="Python hljs livecodeserver" style="box-sizing: border-box; font-size: 1.75 rem; font-family: &quot;Input Sans Narrow&quot;; color: rgb(51, 51 , 51 ); background: rgb(248, 248 , 248 ); border-radius: 0 px; line-height: 25 px; padding: 0.5 em 16 rem; white-space: pre; font-feature-settings: &quot;zero&quot;; letter-spacing: 0 px; display: block; overflow-x: auto; border-top: 1 px solid rgb(224, 224 , 225 ); border-bottom: 1 px solid rgb(224, 224 , 225 );">my_variable = my_dict[<span class="hljs-string" style="box-sizing: border-box; color: rgb(221, 17 , 68 );">'my_nested_dict'</span>]</code>

    字典理解–少即是多

    定义字典的更高级技术是使用Python字典理解。 就像列表推导一样,字典推导会以比上述符号更简洁的格式生成动态大小的字典:

    <code class="Python hljs livecodeserver" style="box-sizing: border-box; font-size: 1.75 rem; font-family: &quot;Input Sans Narrow&quot;; color: rgb(51, 51 , 51 ); background: rgb(248, 248 , 248 ); border-radius: 0 px; line-height: 25 px; padding: 0.5 em 16 rem; white-space: pre; font-feature-settings: &quot;zero&quot;; letter-spacing: 0 px; display: block; overflow-x: auto; border-top: 1 px solid rgb(224, 224 , 225 ); border-bottom: 1 px solid rgb(224, 224 , 225 );">automatic_dictionary = {key: value <span class="hljs-keyword" style="box-sizing: border-box; color: rgb(51, 51 , 51 ); font-weight: 700 ;">for</span> (key, value) <span class="hljs-keyword" style="box-sizing: border-box; color: rgb(51, 51 , 51 ); font-weight: 700 ;">in</span> &lt; some_iterable &gt;}</code>

    可以根据键和值(例如元组列表)进行关联的任何可迭代对象,都很容易成为具有一行代码的字典。 根据可迭代对象的大小,字典理解符号可以是一个节省空间的工具(和一个节省生命的工具!),使代码更加“ Pythonic”。

    想要更快地编写代码吗?Kite是PyCharm,Atom,Vim,VSCode,Sublime Text和IntelliJ的插件,它使用机器学习为您提供按相关性实时排序的代码完成。 立即开始编码更快。免费下载Kite

    实际用例

    假设我们需要快速建立模型并存储一些数据,而无需创建类或冗长SQL语句。 例如,我们需要存储一些有关网站用户的数据。

    用户类可能看起来像…

    <codeclass = "Python hljs livecodeserver" style= "box-sizing: border-box; font-size: 1.75rem; font-family: &quot;Input Sans Narrow&quot;; color: rgb(51, 51, 51); background: rgb(248, 248, 248); border-radius: 0px; line-height: 25px; padding: 0.5em 16rem; white-space: pre; font-feature-settings: &quot;zero&quot;; letter-spacing: 0px; display: block; overflow-x: auto; border-top: 1px solid rgb(224, 224, 225); border-bottom: 1px solid rgb(224, 224, 225);" ><span class = "hljs-class" style= "box-sizing: border-box;" ><span class = "hljs-keyword" style= "box-sizing: border-box; color: rgb(51, 51, 51); font-weight: 700;" > class </span> <span class = "hljs-title" style= "box-sizing: border-box; color: rgb(68, 85, 136); font-weight: 700;" >User</span><span class = "hljs-params" style= "box-sizing: border-box;" >( object )</span>:</span>
        <span class = "hljs-string" style= "box-sizing: border-box; color: rgb(221, 17, 68);" > """  Stores info about Users """ </span>
    
        <span class = "hljs-function" style= "box-sizing: border-box;" ><span class = "hljs-keyword" style= "box-sizing: border-box; color: rgb(51, 51, 51); font-weight: 700;" >def</span> <span class = "hljs-title" style= "box-sizing: border-box; color: rgb(153, 0, 0); font-weight: 700;" > __ init __ </span><span class = "hljs-params" style= "box-sizing: border-box;" >(self, name, email, address, password, url)</span>:</span>
            self.name = name
            self.email = email
            ...
    
        <span class = "hljs-function" style= "box-sizing: border-box;" ><span class = "hljs-keyword" style= "box-sizing: border-box; color: rgb(51, 51, 51); font-weight: 700;" >def</span> <span class = "hljs-title" style= "box-sizing: border-box; color: rgb(153, 0, 0); font-weight: 700;" >send _ email</span><span class = "hljs-params" style= "box-sizing: border-box;" >(self)</span>:</span>
            <span class = "hljs-string" style= "box-sizing: border-box; color: rgb(221, 17, 68);" > """ Send an email to our user""" </span>
            <span class = "hljs-keyword" style= "box-sizing: border-box; color: rgb(51, 51, 51); font-weight: 700;" >pass</span>
    
        <span class = "hljs-function" style= "box-sizing: border-box;" ><span class = "hljs-keyword" style= "box-sizing: border-box; color: rgb(51, 51, 51); font-weight: 700;" >def</span> <span class = "hljs-title" style= "box-sizing: border-box; color: rgb(153, 0, 0); font-weight: 700;" > __ repr __ </span><span class = "hljs-params" style= "box-sizing: border-box;" >()</span>:</span>
            <span class = "hljs-string" style= "box-sizing: border-box; color: rgb(221, 17, 68);" > """Logic to properly format data""" </span>
    
    bill = User(<span class = "hljs-string" style= "box-sizing: border-box; color: rgb(221, 17, 68);" > 'Bill' </span>, <span class = "hljs-string" style= "box-sizing: border-box; color: rgb(221, 17, 68);" > 'bill @ gmail.com' </span>, <span class = "hljs-string" style= "box-sizing: border-box; color: rgb(221, 17, 68);" > '123 Acme Dr.' </span>, <span class = "hljs-string" style= "box-sizing: border-box; color: rgb(221, 17, 68);" > 'secret-password' </span>,
                <span class = "hljs-string" style= "box-sizing: border-box; color: rgb(221, 17, 68);" > 'http: // www.bill.com' </span>)
    bill.send _ email()</code>

    这样的类可以具有各种功能,并且开发人员可以就是否使用新的@dataclass功能或我们是否需要类或实例方法等进行争论,但是有了字典,开销就更少了:

    <codeclass = "Python hljs livecodeserver" style= "box-sizing: border-box; font-size: 1.75rem; font-family: &quot;Input Sans Narrow&quot;; color: rgb(51, 51, 51); background: rgb(248, 248, 248); border-radius: 0px; line-height: 25px; padding: 0.5em 16rem; white-space: pre; font-feature-settings: &quot;zero&quot;; letter-spacing: 0px; display: block; overflow-x: auto; border-top: 1px solid rgb(224, 224, 225); border-bottom: 1px solid rgb(224, 224, 225);" >bill = {<span class = "hljs-string" style= "box-sizing: border-box; color: rgb(221, 17, 68);" > 'email' </span>: <span class = "hljs-string" style= "box-sizing: border-box; color: rgb(221, 17, 68);" > 'bill@gmail.com' </span>,
        <span class = "hljs-string" style= "box-sizing: border-box; color: rgb(221, 17, 68);" > 'address' </span>: <span class = "hljs-string" style= "box-sizing: border-box; color: rgb(221, 17, 68);" > '123 Acme Dr.' </span>,
        <span class = "hljs-string" style= "box-sizing: border-box; color: rgb(221, 17, 68);" > 'password' </span>: <span class = "hljs-string" style= "box-sizing: border-box; color: rgb(221, 17, 68);" > 'secret-password' </span>,
        <span class = "hljs-string" style= "box-sizing: border-box; color: rgb(221, 17, 68);" > 'url' </span>: <span class = "hljs-string" style= "box-sizing: border-box; color: rgb(221, 17, 68);" > 'http://www.bill.com' </span>}
    
    <span class = "hljs-function" style= "box-sizing: border-box;" ><span class = "hljs-keyword" style= "box-sizing: border-box; color: rgb(51, 51, 51); font-weight: 700;" >def</span> <span class = "hljs-title" style= "box-sizing: border-box; color: rgb(153, 0, 0); font-weight: 700;" >send_email</span><span class = "hljs-params" style= "box-sizing: border-box;" >(user_dict)</span>:</span>
        <span class = "hljs-keyword" style= "box-sizing: border-box; color: rgb(51, 51, 51); font-weight: 700;" >pass</span>
        <span class = "hljs-comment" style= "box-sizing: border-box; color: rgb(153, 153, 136); font-style: italic;" > # smtp email logic …</span>
    
    send_email(bill[<span class = "hljs-string" style= "box-sizing: border-box; color: rgb(221, 17, 68);" > 'email' </span>])  <span class = "hljs-comment" style= "box-sizing: border-box; color: rgb(153, 153, 136); font-style: italic;" > # bracket notation or …</span>
    send_email(bill. get (<span class = "hljs-string" style= "box-sizing: border-box; color: rgb(221, 17, 68);" > 'email' </span>))  <span class = "hljs-comment" style= "box-sizing: border-box; color: rgb(153, 153, 136); font-style: italic;" > # .get() method is handy, too</span></code>

    现在我们可以像拥有Bill对象一样直观地拥有bill的数据,以及一半的代码。

    遍历字典中存储的数据

    由于JSON响应通常是字典列表(可能是从API响应中解析以生成User实例列表),因此我们可以遍历该字典以创建一些User实例。

    <codeclass = "Python hljs livecodeserver" style= "box-sizing: border-box; font-size: 1.75rem; font-family: &quot;Input Sans Narrow&quot;; color: rgb(51, 51, 51); background: rgb(248, 248, 248); border-radius: 0px; line-height: 25px; padding: 0.5em 16rem; white-space: pre; font-feature-settings: &quot;zero&quot;; letter-spacing: 0px; display: block; overflow-x: auto; border-top: 1px solid rgb(224, 224, 225); border-bottom: 1px solid rgb(224, 224, 225);" >json_response = [{
      <span class = "hljs-string" style= "box-sizing: border-box; color: rgb(221, 17, 68);" > "id" </span>: <span class = "hljs-number" style= "box-sizing: border-box; color: teal;" > 1 </span>,
      <span class = "hljs-string" style= "box-sizing: border-box; color: rgb(221, 17, 68);" > "first_name" </span>: <span class = "hljs-string" style= "box-sizing: border-box; color: rgb(221, 17, 68);" > "Florentia" </span>,
      <span class = "hljs-string" style= "box-sizing: border-box; color: rgb(221, 17, 68);" > "last_name" </span>: <span class = "hljs-string" style= "box-sizing: border-box; color: rgb(221, 17, 68);" > "Schelle" </span>,
      <span class = "hljs-string" style= "box-sizing: border-box; color: rgb(221, 17, 68);" > "email" </span>: <span class = "hljs-string" style= "box-sizing: border-box; color: rgb(221, 17, 68);" > "fschelle0@nyu.edu" </span>,
      <span class = "hljs-string" style= "box-sizing: border-box; color: rgb(221, 17, 68);" > "url" </span>: <span class = "hljs-string" style= "box-sizing: border-box; color: rgb(221, 17, 68);" > "https://wired.com" </span>
    }, {
      <span class = "hljs-string" style= "box-sizing: border-box; color: rgb(221, 17, 68);" > "id" </span>: <span class = "hljs-number" style= "box-sizing: border-box; color: teal;" > 2 </span>,
      <span class = "hljs-string" style= "box-sizing: border-box; color: rgb(221, 17, 68);" > "first_name" </span>: <span class = "hljs-string" style= "box-sizing: border-box; color: rgb(221, 17, 68);" > "Montague" </span>,
      <span class = "hljs-string" style= "box-sizing: border-box; color: rgb(221, 17, 68);" > "last_name" </span>: <span class = "hljs-string" style= "box-sizing: border-box; color: rgb(221, 17, 68);" > "McAteer" </span>,
      <span class = "hljs-string" style= "box-sizing: border-box; color: rgb(221, 17, 68);" > "email" </span>: <span class = "hljs-string" style= "box-sizing: border-box; color: rgb(221, 17, 68);" > "mmcateer1@zdnet.com" </span>,
      <span class = "hljs-string" style= "box-sizing: border-box; color: rgb(221, 17, 68);" > "url" </span>: <span class = "hljs-string" style= "box-sizing: border-box; color: rgb(221, 17, 68);" > "https://domainmarket.com" </span>
    }, {
      <span class = "hljs-string" style= "box-sizing: border-box; color: rgb(221, 17, 68);" > "id" </span>: <span class = "hljs-number" style= "box-sizing: border-box; color: teal;" > 3 </span>,
      <span class = "hljs-string" style= "box-sizing: border-box; color: rgb(221, 17, 68);" > "first_name" </span>: <span class = "hljs-string" style= "box-sizing: border-box; color: rgb(221, 17, 68);" > "Dav" </span>,
      <span class = "hljs-string" style= "box-sizing: border-box; color: rgb(221, 17, 68);" > "last_name" </span>: <span class = "hljs-string" style= "box-sizing: border-box; color: rgb(221, 17, 68);" > "Yurin" </span>,
      <span class = "hljs-string" style= "box-sizing: border-box; color: rgb(221, 17, 68);" > "email" </span>: <span class = "hljs-string" style= "box-sizing: border-box; color: rgb(221, 17, 68);" > "dyurin2@e-recht24.de" </span>,
      <span class = "hljs-string" style= "box-sizing: border-box; color: rgb(221, 17, 68);" > "url" </span>: <span class = "hljs-string" style= "box-sizing: border-box; color: rgb(221, 17, 68);" > "http://wufoo.com" </span>
    }]</code>

    注意字典作为数据行的自然结构。 我们可以轻松地遍历这些行以创建我们的User对象。

    <codeclass = "Python hljs livecodeserver" style= "box-sizing: border-box; font-size: 1.75rem; font-family: &quot;Input Sans Narrow&quot;; color: rgb(51, 51, 51); background: rgb(248, 248, 248); border-radius: 0px; line-height: 25px; padding: 0.5em 16rem; white-space: pre; font-feature-settings: &quot;zero&quot;; letter-spacing: 0px; display: block; overflow-x: auto; border-top: 1px solid rgb(224, 224, 225); border-bottom: 1px solid rgb(224, 224, 225);" >users = []
    <span class = "hljs-keyword" style= "box-sizing: border-box; color: rgb(51, 51, 51); font-weight: 700;" > for </span> i <span class = "hljs-keyword" style= "box-sizing: border-box; color: rgb(51, 51, 51); font-weight: 700;" > in </span> json_response:
        users.append(User(
            name=i [<span class="hljs-string" style="box-sizing: border-box; color: rgb(221, 17, 68);">'first_name'</span>] + i [<span class="hljs-string" style="box-sizing: border-box; color: rgb(221, 17, 68);">'last_name'</span>] ,
            email = i [<span class="hljs-string" style="box-sizing: border-box; color: rgb(221, 17, 68);">'email'</span>] ,
            url=i [<span class="hljs-string" style="box-sizing: border-box; color: rgb(221, 17, 68);">'url'</span>] ,
            <span class = "hljs-comment" style= "box-sizing: border-box; color: rgb(153, 153, 136); font-style: italic;" ># ...</span>
        ))</code>

    字典作为嵌套数据结构

    与列表相比,Python词典乍看起来似乎是死板而又不能原谅的:冒号和括号的名副其实的汤。 但是,与存储在关系数据库中的数据相比(字典中的值必须符合特定的约束条件才能使关系成为可能),字典非常灵活。

    一方面,字典中的值可以是任何python对象,并且通常使用字典中的值实例化对象的集合。 值通过简单地“附加”便与其他值相关。 也就是说,将一个值放在列表或字典中,第一个值为键。 尽管以这种方式创建的字典可能看起来很复杂,但是将特定值从字典中拉出实际上比编写SQL查询要简单得多。

    由于它们的结构,Python词典是理解其他嵌套数据结构(例如JSON或XML)的好方法-嵌套数据结构通常被称为非关系数据结构,除了关系数据库(如MySQL,PostgreSQL和其他数据库)外,它还包含所有内容。

    刚度较小的结构的优点是可以轻松获取特定值。 缺点是,在其他键下的相应嵌套“级别”上的值集更难以彼此关联,并且生成的代码更冗长。 如果数据自然地落入列和行中,则更适合使用Pandas DataFrame或Numpy ndarray之类的东西,从而允许通过值在向量空间中的相对位置来引用值。

    JSON的Python主页

    尽管Python字典和JSON(JavaScript对象表示法)之间有一些细微的差异,但是这两种数据结构之间的相似性对于使用其他来源的数据的开发人员来说是一个很大的收获。 实际上,对请求库的响应调用.json()方法将返回一个字典。

    最近,JSON已成为通过API进行数据交换的事实上的媒介,诸如XML和YAML的标记语言在很大程度上落后于后者。 导致这种情况的原因很可能是JavaScript的普及以及对Web服务能够将JavaScript与其他Web服务“说”的需求。 有些人认为,JSON的解压缩工作量很少。

    幸运的是,或者也许是通过设计,Python很适合通过其本机数据结构(Python字典)使用JSON。 话虽这么说,这里有一些区别:

    JSON用于序列化尽管Python开发人员习惯于操作内存中的Python对象,但JSON却是另一回事。 取而代之的是,JSON是一种标准,用于序列化各种数据以像通过HTTP的电报一样发送。 JSON通过网络传输后,就可以反序列化或加载到Python对象中。 JSON可以是一个字符串在JSON对象成为Python逻辑之前,它们通常是作为对HTTP请求的响应而发送的字符串,然后以各种方式进行解析。 JSON响应通常看起来像是用引号引起来的字典列表。 方便地,字典列表可以轻松地解析为更有用的对象,例如Pandas DataFrames(Pandas是Python的强大数据分析工具)。 每当加载和转储(序列化)JSON对象时,它们在某些时候都将成为Python中的字符串。 重复键 Python字典键必须唯一。 换句话说,some_dictionary.keys()将是一组唯一值。 JSON并非如此-这有点不寻常,因为它似乎一开始就破坏了密钥的用途-但从未有人说JSON是伪造的。 将JSON转换为Python对象时必须明确处理重复的键,否则只有一个键值对才能通过。想要更快地编写代码?Kite是PyCharm,Atom,Vim,VSCode,Sublime Text和IntelliJ的插件,使用机器学习为您实时提供按相关性排序的代码完成。 立即开始编码更快。免费下载Kite

    陷阱和类似字典的选择

    字典非常有用,但是语言规范的某些方面导致字典似乎行为不当。 例如,当遍历字典时,开发人员可以引用尚未定义的键值对。 Python字典不会返回“ None”,而是会引发错误并打印出回溯,如果未处理错误,则会完全停止执行。 此行为可能会减慢开发周期。

    <code class="html hljs xml" style = "box-sizing: border-box; font-size: 1.75rem; font-family: &quot;Input Sans Narrow&quot;; color: rgb(51, 51, 51); background: rgb(248, 248, 248); border-radius: 0px; line-height: 25px; padding: 0.5em 16rem; white-space: pre; font-feature-settings: &quot;zero&quot;; letter-spacing: 0px; display: block; overflow-x: auto; border-top: 1px solid rgb(224, 224, 225); border-bottom: 1px solid rgb(224, 224, 225);" >&gt;&gt;&gt; print (my_dict['my_key'])
    Traceback (most recent call last ):
      File "<span class=" hljs-tag " style=" box -sizing: border - box ; color : navy; font -weight: 400 ; ">&lt;<span class=" hljs-name " style=" box -sizing: border - box ; color : navy; font -weight: 400 ; ">input</span>&gt;</span>" , line 1 , in <span class= "hljs-tag" style = "box-sizing: border-box; color: navy; font-weight: 400;" >&lt;<span class= "hljs-name" style = "box-sizing: border-box; color: navy; font-weight: 400;" >module</span>&gt;</span>
    KeyError: 'my_key'</code>

    由于程序通常可能只需要“检查”键值对的存在而不会引发错误,因此开发人员还有其他选择。 第一种是从collections模块导入defaultdict对象,这是一个自动覆盖的默认值自动覆盖的对象。 而不是显示错误,而是返回默认值。

    其次,标准字典上的.get()方法可能返回作为第二个参数传递的任何值。 因此,引用一个值代替括号表示法,就像…

    <codeclass = "Python hljs livecodeserver" style= "box-sizing: border-box; font-size: 1.75rem; font-family: &quot;Input Sans Narrow&quot;; color: rgb(51, 51, 51); background: rgb(248, 248, 248); border-radius: 0px; line-height: 25px; padding: 0.5em 16rem; white-space: pre; font-feature-settings: &quot;zero&quot;; letter-spacing: 0px; display: block; overflow-x: auto; border-top: 1px solid rgb(224, 224, 225); border-bottom: 1px solid rgb(224, 224, 225);" >just_checking = my_dict.get( < span class = "hljs-string" style = "box-sizing: border-box; color: rgb(221, 17, 68);" > 'my_key’, None) </ span > < span class = "hljs-string" style = "box-sizing: border-box; color: rgb(221, 17, 68);" >
    &gt;&gt;&gt; print(just_checking) </ span > < span class = "hljs-string" style = "box-sizing: border-box; color: rgb(221, 17, 68);" >
    None </ span > </ code >

    好多了!

    OrderedDict

    字典被定义为键/值对的“无序”集合,这可能会带来不便。 为了添加有序行为,我们也有来自collections模块的OrderedDict 顾名思义,OrderedDict会按定义的返回顺序维护返回对。

    尽管不如标准字典轻巧,但许多开发人员更喜欢使用OrderedDict,因为它的行为方式更可预测。 在标准字典中进行迭代时,键值对将以随机顺序返回。 OrderedDict始终以相同顺序返回对,这对于在大型数据集中查找特定对时很有用。 支持defaultdict和OrderedDict的人不要问“为什么?” –他们问:“为什么不呢?”

    性能考量

    您在Python应用程序中看到的性能不佳吗? 停止遍历列表,并开始引用字典中的值。

    从技术上讲,可以使用列表来模仿字典的功能。 用列表创建键值对通常是一种编程入门。 但是,对于像Python这样的高级语言来说,拥有高性能的实现至关重要。 原因之一是Python语言实现本身在内部使用字典。

    另一个原因是字典的执行速度比列表快。 在Python列表中,要找到特定项目,必须检查每个项目,直到找到匹配项。 对于字典,唯一选中的项目是与特定键相关联的项目(或对象或集合)。 这具有显着提高性能的效果,通常提高了几个数量级。

    从这往哪儿走…

    了解字典的最佳方法是进行练习! 尝试遍历字典,将键和值存储在单独的列表中,然后以适当的顺序将它们重新分配给彼此。

    尝试根据字典创建有趣的对象系列,以及根据对象创建字典。 如果您必须在字典中存储1000行数据,那么解决该问题的一个很好的Python模式是什么?

    在运行堆栈交换之前,请考虑一下字典的性质。 密钥是唯一值,还是可以重复? 如果它们是唯一的,哪种类型的Python集合可以最好地存储值? 现在,尝试搜索规范的解决方案。 当然,不要忘了查看字典中的官方Python文档:

    https://docs.python.org/3/tutorial/datastructures.html

    Python字典是Python中的基本数据结构,并且是Python语言规范的核心组件。 谨慎对待后,词典将成为高性能的工具,以一种明确,易读且最重要的是Python方式存储和访问复杂数据。

    这篇文章是Kite关于Python的新系列的一部分。 您可以从我们的GitHub存储库中的这篇文章和其他文章中查看代码。

    本文最初在风筝上发表。



    翻译自: https://hackernoon.com/guide-to-python-dictionaries-gymx30aw

    python字典包含字典

    展开全文
  • Python字典

    2019-09-28 00:25:29
    Python基础数据类型之字典 一、什么是字典Python的字典,也称为hash或关系数组,是Python的基础数据类型之一,也其唯一的映射类型。区别于序列类型,序列类型...字典的键必须独一无二的,而值可以取任何类型,...

    Python基础数据类型之字典

    一、什么是字典

    Python的字典,也称为hash或关系数组,是Python的基础数据类型之一,也是其唯一的映射类型。区别于序列类型,序列类型通过数组的形式存储,
    通过索引的方式来取得对应位置上的值,索引与其对应的值本身并没有关系。而字典是一种映射类型,本身是没有顺序的,通过Key-Value的的对应关
    系来取值。字典的键必须是独一无二的,而值可以取任何类型,但是值必须是不可变的,如字符串、数组或元组

    二、如何创建字典

    方法1:将键值对用大括号包裹起来,之间用逗号隔开就创建了一个字典,如果要创建一个空字典,直接一对大括号即可。
    >>> dict1 = {}                      #创建一个空字典
    >>> type(dict1)
    <class 'dict'>
    >>> dict2 = {'A':1,'B':2,'C':3}     #用键值对创建一个字典,键分别为'A','B','C',值分别为1,2,3
    >>> dict2
    {'A': 1, 'B': 2, 'C': 3}
    >>> type(dict2)
    <class 'dict'>
    >>>
    方法2:用dict()函数将一堆由映射关系的数据转换为字典
    方法2:用dict()函数将一堆由映射关系的数据转换为字典
    
    >>> dict1 = dict(A=1,B=2,C=3)
    >>> dict2 = dict([('A',1),('B',2),('C',3)])
    >>> dict3 = dict({'A':1,'B':2,'C':3})
    >>> dict4 = dict(zip(['A','B','C'],[1,2,3]))
    >>> dict1
    {'A': 1, 'B': 2, 'C': 3}
    >>> dict2
    {'A': 1, 'B': 2, 'C': 3}
    >>> dict3
    {'A': 1, 'B': 2, 'C': 3}
    >>> dict4
    {'A': 1, 'B': 2, 'C': 3}
    >>> dict1 == dict2 == dict3 == dict4
    True
    >>>
    三、访问字典

    要访问字典里的值,可以使用下面的方式
    >>> dict1 = {'A':1,'B':2,'C':3}
    >>> dict1['A']
    1
    >>> dict1['B']
    2
    >>>
    四、字典的方法

    1.clear()
    清空字典
    >>> dict1 = {'A':1,'B':2,'C':3}
    >>> dict1.clear()
    >>> dict1
    {}
    >>>
    2.copy()
    浅拷贝一个字典
    >>> dict1 = {'A':1,'B':2,'C':3}
    >>> dict2 = dict1.copy()
    >>> dict2
    {'A': 1, 'B': 2, 'C': 3}
    >>>
    3.fromkeys()
    用于创建并返回一个新的字典,它有两个参数,第一个参数是字典的键,第二个参数是可选的,是传入键对应的值,默认为None。
    >>> dict1 = {}
    >>> dict1.fromkeys((1,2,3,4))
    {1: None, 2: None, 3: None, 4: None}
    >>> dict1.fromkeys((1,2,3,4),'Keys')
    {1: 'Keys', 2: 'Keys', 3: 'Keys', 4: 'Keys'}
    >>>
    4.get()
    根据键获得其对应的值,当键不存在时,返回None,如果想要没有找到时返回自己想要返回的数据,在其后面添加参数即可。
    >>> dict1 = {'A':1,'B':2,'C':3}
    >>> dict1.get('A')
    1
    >>> dict1.get('C')
    3
    >>> dict1.get('D')
    >>> dict1.get('D','没有找到')
    '没有找到'
    >>>
    5.items()
    获得字典所有的项
    >>> dict1 = {'A':1,'B':2,'C':3}
    >>> dict1.items()
    dict_items([('A', 1), ('B', 2), ('C', 3)])
    >>>
    6.keys()
    获得字典所有的键
    >>> dict1 = {'A':1,'B':2,'C':3}
    >>> dict1.keys()
    dict_keys(['A', 'B', 'C'])
    >>>
    7.pop()
    给定字典的键弹出其对应的值
    >>> dict1 = {'A':1,'B':2,'C':3}
    >>> dict1.pop('A')
    1
    >>> dict1.pop('C')
    3
    >>> dict1
    {'B': 2}
    >>>
    8.popitem()
    随机弹出字典的一个项
    >>> dict1 = {'A':1,'B':2,'C':3}
    >>> dict1.popitem()
    ('C', 3)
    >>> dict1
    {'A': 1, 'B': 2}
    >>> dict1.popitem()
    ('B', 2)
    >>> dict1
    {'A': 1}
    >>>
    9.setdefault()
    setdefault()方法和get()方法有些类似,不同之处在于setdefault()方法找不到键时会自己添加一个
    >>> dict1 = {'A':1,'B':2,'C':3}
    >>> dict1.setdefault('B')
    2
    >>> dict1
    {'A': 1, 'B': 2, 'C': 3}
    >>> dict1.setdefault('D')
    >>> dict1
    {'A': 1, 'B': 2, 'C': 3, 'D': None}
    >>>
    10.update()
    更新字典
    >>> dict1 = {'A':1,'B':2,'C':3}
    >>> dict1.update(A='a')
    >>> dict1
    {'A': 'a', 'B': 2, 'C': 3}
    >>>
    11.values()
    获得字典的所有值
    >>> dict1 = {'A':1,'B':2,'C':3}
    >>> dict1.values()
    dict_values([1, 2, 3])
    >>>
    
    

    转载于:https://www.cnblogs.com/Keys819/p/9296216.html

    展开全文
  • python字典

    2021-02-26 10:36:05
    字典:将多个数据存储在一个“无序”容器中(Python3.5无序,在Python3.6中有序),并且通过“名字”来访问。 什么情况下会使用字典: # 存储三门课成绩 # 语文:79 数学:80 英语:92 s1 = [79,80,92] s2...

    字典

    一、什么是字典

    • Python中的字典是另一种可变容器

    • 可以存储任意类型的数据

    列表:将多个数据存储在一个有序的容器中,并且通过下标/索引形式来访问

    字典:将多个数据存储在一个“无序”的容器中(Python3.5是无序的,在Python3.6中有序),并且通过“名字”来访问。

    • 什么情况下会使用字典:
    # 存储三门课的成绩
    # 语文:79  数学:80  英语:92
    s1 = [79,80,92]
    s2 = ['语文','数学','英语']   # 列表是 下标和值绑定
    
    print(s2[0],s1[0])
    
    # 产生一个 一 一对应关系(映射) -- 字典  键和值绑定
    scores = {'语文':79, '数学':80, '英语':92}
    # 声明了一个字典,有3个元素,每一个元素都由两部分组成,key:value 键:值
    print(scores['语文'])
    
    • 存储一个人的信息 姓名:Mr_lee 年龄:18 性别:True

      • 列表:

        ` info = ['Mr_lee',18,True]    info[0]`
        
      • 字典:

        `info = {'name':'Mr_lee', 'age':18, 'gender':True}  info['name']`
        

    二、字典的创建

    • 直接使用{}来创建
    d1 = {}  # 构造了一个空字典
    print(type(d1))   # dict   -- dictionary
    d2 = {'A': 1,  'C': 3, 'B': 2,}  # 存储多个键值对 Python3.6 存储的先后顺序排序
    print(d2)
    
    • 工厂函数
    # 1. 空字典
    d = dict()  # 空字典
    # 2. 使用映射构造
    d = dict({'A': 1,  'C': 3, 'B': 2,} )  # l = list([1,2,3])
    
    # 3. 使用可迭代对象构造
    d = dict([1,2,3])  # 不行
    # 如果使用可迭代对象作为参数构造字典,要求可迭代对象中的每一个元素由两个子元素构造
    d = dict([('A',1),('B',2)])
              
    d = dict(['A1','B2'])  # {'A': '1', 'B': '2'}
    print(d)   
    
    # 4. 可以使用关键字参数构造字典
    d = dict(a=1,b=2,c=3)
    print(d)  # {'a': 1, 'b': 2, 'c': 3}
    
    

    三、字典的访问

    • 列表是通过下标索引的方式来访问它的元素的,而字典则是通过键名来获取对应的值
    info = {'id':1, 'name':'Mr_lee', 'age':18, 'age':20}  # 不允许有重复的键 不报错 会发生覆盖
    
    print(info['name'])
    print(info['Name'])   # KeyError: 'Name'  当键不存在时,访问报错   
    
    
    # 解决键不存在时,访问键对应的值时,程序出错: get函数
    n = info.get('Name')  # 当键不存在时,返回为None
    print(n)  # None
    
    n = info.get('NAME','Tom')  # 当键不存在时,返回第二个参数的值(默认的值)
    print(n)  # Tom
    
    n = info.get('name','Tom')
    print(n)  # Mr_lee
    

    注意:字典中的键一般都是字符串 ,键必须是不可变类型

    d = {1:1,2:2,3:3}   # 可以
    d = {'A': 1,  'C': 3, 'B': 2,} # 可以
    d = {(1,):1,(2,):2}  # 可以 使用元组作为键,要求元组中的元素也必须不可变类型
    d =  {[1,]:1,[2,]:2} # 不可以 
    

    四、修改和添加元素

    info = {'id':1, 'name':'Mr_lee', 'age':18}
    
    id = info.get('id')  # 作为右值
    print(id)
    
    id = info['id']   # 作为右值
    print(id)
    
    • 修改数据
    #  当键存在时,并作为左值,则是修改它的值
    
    info['id'] = 100  # 作为左值,修改它的值    s[0] = 100 
    print(info)  # {'id':100, 'name':'Mr_lee', 'age':18}
    
    • 添加数据
    # 当键不存在时,作为左值,添加一个键值对
    info['gender'] =  True  # {'id': 100, 'name': 'Mr_lee', 'age': 18, 'gender': True}
    print(info)
    

    五、字典常用的方法

    函数 描述
    d.clear() 清空字典中的所有的元素
    d.pop(key) 删除指定键对应的值(kv一起被删除)
    d.popitem() 随机移除并返回被移除的键值对 类型是一个元组(k,v)
    d.get(key,default) 返回指定键对应的值,当键不存在时,返回为空,如果给了default则当键不存在时,返回default的值
    d.items() 以列表的形式返回所有的键值对,列表中的每一个元素都是一个元组包含一个键和值 dict_items([('id', 1), ('name', 'Mr_lee'), ('age', 18)])
    d.keys() 返回所有的键
    d.values() 返回所有的值
    d1.update(d2) 用一个字典/可迭代对象来更新另一个字典
    d.copy() 拷贝一个字典
    • 删除和清空
    info.clear()  # 清空
    print(info)
    
    v = info.pop('name') # 移除指定的键和值 返回对应的值
    print(v)
    print(info)  # {'id': 1, 'age': 18}
    
    item = info.popitem()  # 随机返回一个键值对 tuple 如果字典为空,则KeyError
    print(item)
    
    • 获取值
    info = {'id':1, 'name':'Mr_lee', 'age':18, 'age':20}
    print(info)
    
    # print(info['Name'])  # KeyError: 'Name'
    
    n = info.get('Name')  # 当键不存在时,返回为None
    print(n)  # None
    
    n = info.get('NAME','Tom')  # 当键不存在时,返回第二个参数的值(默认的值)
    print(n)  # Tom
    
    n = info.get('name','Tom')
    print(n)  # Mr_lee
    
    • 返回所有的键值对
    items = info.items()
    print(items)         # dict_items([('id', 1), ('name', 'Mr_lee'), ('age', 18)])
    print(list(items))   # [('id', 1), ('name', 'Mr_lee'), ('age', 18)]
    
    for k,v in list(items):
        print(k,v)
    
    • 返回所有的键 或 返回所有的值
    print(info.keys())# dict_keys(['id', 'name', 'age']) 可迭代对象 可以转为list
    
    for key in info.keys():
        print(key)
    
    print(info.values())
    
    • update函数
    info = {'id': 1, 'name': 'Mr_lee', 'age': 18}
    
    d = {'height': 180, 'weight': 180}
    
    info.update(d)  # 类似于列表中的extend
    info.update(['A1', 'B2'])
    print(info)
    
    • 字典的遍历
    # 3.5/3.6
    info = {'id': 1, 'name': 'Mr_lee', 'age': 18}
    info = {'id': 1, 'name': 'Mr_lee', 'age': 18}
    for k in info:           # 默认获取的是键 key
        print(k,info.get(k)) 
    
    for k in info.keys():
        print(k)
    
    for k,v in info.items():  # 一次性获取所有的键值对
        print(k,v)
        
    
    展开全文
  • 综述迭代器对于原生支持随机访问的数据结构(如tuple、list),迭代器和经典for循环的索引访问相比并无优势,反而丢失了索引值(可以使用内建函数enumerate()找回这个索引值)。但对于无法随机访问的数据结构(比如...

    综述迭代器

    对于原生支持随机访问的数据结构(如tuple、list),迭代器和经典for循环的索引访问相比并无优势,反而丢失了索引值(可以使用内建函数enumerate()找回这个索引值)。但对于无法随机访问的数据结构(比如set)而言,迭代器是唯一的访问元素的方式。

    另外,迭代器的一大优点是不要求事先准备好整个迭代过程中所有的元素。迭代器仅仅在迭代到某个元素时才计算该元素,而在这之前或之后,元素可以不存在或者被销毁。这个特点使得它特别适合用于遍历一些巨大的或是无限的集合,比如几个G的文件,或是斐波那契数列等等。

    迭代器更大的功劳是提供了一个统一的访问集合的接口,只要定义了iter()方法对象,就可以使用迭代器访问。

    例如:

    List = [1,2,3]

    L = List.__iter__()

    >>> L.next()

    1

    >>> L.next()

    2

    >>> L.next()

    3

    为什么使用迭代器

    for i in range(1000): pass

    for i in xrange(1000): pass

    前一个返回1000个元素的列表,而后一个在每次迭代中返回一个元素,因此可以使用迭代器来解决复用可占空间的问题

    class Fab(object):

    def __init__(self, max):

    self.max = max

    self.n, self.a, self.b = 0, 0, 1

    def __iter__(self):

    return self

    def next(self):

    if self.n < self.max:

    r = self.b

    self.a, self.b = self.b, self.a + self.b

    self.n = self.n + 1

    return r

    raise StopIteration()

    Fab 类通过 next() 不断返回数列的下一个数,内存占用始终为常数

    示例代码2

    def fab(max):

    n, a, b = 0, 0, 1

    while n < max:

    yield b

    a, b = b, a + b

    n = n = 1

    简单地讲,yield 的作用就是把一个函数变成一个 generator,带有 yield 的函数不再是一个普通函数,Python 解释器会将其视为一个 generator,调用 fab(5) 不会执行 fab 函数,而是返回一个 iterable 对象!

    在 for 循环执行时,每次循环都会执行 fab 函数内部的代码,执行到 yield b 时,fab 函数就返回一个迭代值,下次迭代时,代码从 yield b 的下一条语句继续执行,而函数的本地变量看起来和上次中断执行前是完全一样的,于是函数继续执行,直到再次遇到 yield。

    看起来就好像一个函数在正常执行的过程中被 yield 中断了数次,每次中断都会通过 yield 返回当前的迭代值。

    以上这篇python 字典item与iteritems的区别详解就是小编分享给大家的全部内容了,希望能给大家一个参考,也希望大家多多支持脚本之家。

    展开全文
  • Python字典的底层原理

    2019-12-10 11:20:28
    1.python字典及其特性 字典Python的一种可变、无序容器数据结构,它的元素以键值对的形式... Python字典的底层实现哈希表。什么是哈希表,简单来说就是一张带索引和存储空间的表,对于任意可哈希对象,通过哈希...
  • python字典的用法

    千次阅读 2019-01-27 20:30:00
    1.什么是字典  1.字典一种可变的容器,可以存储任意类型的数据  2.字典中的每个数据都用'键'(key)来进行索引的,而不向列表和元组中可以使用整数下标来进行索引  3.字典中的数据没有先后顺序的,字典的...
  • Python字典类型及操作

    2020-03-29 01:11:07
    Python字典类型及操作 1.首先理解什么是“映射” 映射一种键(索引)和值(数据)的对应, 字典类型“映射的体现”。 2.Python中生成字典的三种方法: 1.字典变量 = {键1:值1.....键n:值n} 2.值 = 字典变量[键...
  • python数据字典的操作

    2018-05-22 19:38:00
    一、什么是字典字典是Python语言中唯一映射类型。 映射类型对象里哈希值(键,key)和指向对象(值,value)一对多的的关系,通常被认为可变哈希表。 字典对象可变,它一个容器类型,能存储...
  • 一、什么是字典字典是Python语言中唯一映射类型。 映射类型对象里哈希值(键,key)和指向对象(值,value)一对多的的关系,通常被认为可变哈希表。 字典对象可变,它一个容器类型,能存储任意...
  • python的字典

    2018-07-19 22:35:59
    1、为什么需要字典类型? list2[0] //在直接编程时,并不能理解第一个索引表示姓名 ‘fentiao’ list2[name] Traceback (most recent call last): File “”, line 1, in ...故字典是python中唯一映射类...
  • 六、Python的字典

    2020-11-05 23:17:41
    将姓名放在一个列表中,将对应的电话放在另外一个列表里,然后根据查找姓名得到的索引,来找对应电话号码列表里的元素,这以前我们查找某人电话号码的方式。 现在姓名和电话号码存储在两个列表中,但是,我希望...
  • 咱们之前讲了字符串比较...1、in运算符(在……里)作用:in 用于序列、字典、集合中,用于判断某个值是否存在于容器中,如果存在则返回True,否则返回False。 格式:对象 in 容器 例:定义一个变量S,并给这个变...
  • 字典是Python中唯一内建映射数据结构类型。 这里映射指通过名字引用值。   字典值并没有特殊顺序,值都存储在一个特定键里。 键可以数字、字符串甚至元祖。   什么是键,什么是值,...
  • Python字典

    2018-10-29 18:45:39
    字典 dict **什么是字典** 1.... 字典中的数据没有先后顺序关系,字典的存储无序的 4. 字典中的数据以键(key)-值(value)对形式进行存储 5. 字典的键不能重复,且只能用不可变类型作为字典的键...
  • Blog9@python字典(dict)

    2018-01-04 16:19:58
    故字典是python中唯一的映射类型,key-value(哈希表),字典对象可变的,但key必须用不可变对象。 2. 字典的创建方式 1)赋值创建字典,key-value , 键值对 2)通过工厂函数创建字典 3)通过字典的fro
  • 字典 dict 什么是字典: 1. 字典一种可变的容器...3. 字典中的数据没有先后顺序关系,字典的存储无序的 4. 字典中的数据以键-值对(key-value)对形式进行映射存储 5. 字典的键不能重复,且只能用不可变类型作为...
  • 一、什么是字典  dict 用{}表示,用来存放键值对数据 ... 字典是无序,没有索引  值:没有任何限制 已知可哈希(不可变)数据类型:int,str,bool,tuple 不可哈希(可变)数据类型:list,d...
  • 009 Python的字典

    2018-06-13 22:31:08
    一、什么是字典1.一种可变的容器,可以存储任意类型的数据 2....键不能重复,否则可能会丢失,且只能用不可变类型[W用2] 作为字典的键 值可以任何类型 字典的字面值表示方式 用花括号{ }括起来,用冒号:分隔...
  • python3字典的应用方法及技巧

    千次阅读 多人点赞 2020-02-06 14:07:33
    3、字典的数据没有先后顺序关系,字典的存储无序的 4、字典中的数据以键(key) – 值(value)对进行映射存储 5、字典的键不能重复,且只能用不可变类型作为字典的键 6、字典的字面值表示方法: 用{}括起来,以...
  • 1、串联比较2、串联调用3、复制列表4、字取元素值5、 按值排序6、 For Else7、列表转换为逗号分隔符串8、合并字典9、寻找列表中最大和最小元素的索引若有不明白的地方,请移步Python视频教程继续学习!!python教...
  • python 数据字典应用

    2016-09-08 20:47:00
    一、什么是字典字典是Python语言中唯一映射类型。 映射类型对象里哈希值(键,key)和指向对象(值,value)一对多的的关系,通常被认为可变哈希表。 字典对象可变,它一个容器类型,能存储...
  • Python——列表和字典的区别

    热门讨论 2020-10-30 11:19:42
    目录列表列表具有“异构性”,可以包含不同类型对象列表“有序”,切片,左闭右开负索引步进切片列表插入,修改,删除不需要重新建表排序字典读取插入用列表生成字典用键值对元组组成字典获取键值删除键排序 ...
  • python——字典数据类型

    千次阅读 2019-05-05 22:52:17
    但是字典的下标就比较牛皮了,字典的索引可以使用许多不同的数据类型,不只整数。 字典的索引被称为“键”,键与其所对应的值被称为“键值对”。 myCat = {'name': 'Tom', 'size': 'fat', 'color': 'black'} 这将...
  • python学习——字典

    2020-06-18 18:59:41
    字典是python中唯一内置映射类型,其中值不按顺序排列,而是存储在键下。键可能数、字符串、元组。这种通过名称来访问其各个值数据结构叫做映射。 一、为什么要使用字典? # 当有了姓名名单 names = ['alice...
  • 字典 in python

    2018-01-24 22:29:28
    或许发明这种数据结构的人就是受了现实世界中字典的启发呢! 字典在不同的语言中都存在,只不过名字不一样而已。如在C++中叫map,在JAVA中叫 HashTable 或者 HashMap。 电话本就是一种典型的字典数据结构,如王三-...
  • 什么是字典字典是Python语言中唯一映射类型。 映射类型对象里哈希值(键,key)和指向对象(值,value)一对多关系,通常被认为可变哈希表。 字典对象可变,它一个容器类型,能存储任意个数...

空空如也

空空如也

1 2 3 4 5 ... 14
收藏数 263
精华内容 105
关键字:

python字典的索引是什么

python 订阅