node7.html

同样是来自国外的经典python教材

= 12345, 54321, 'hello!'</code> 这个叙述是一个tuple包装(  <i>tuple packing</i> )的例子：
                                                              <code>12345</code>
, <code>54321</code> 以及 <code>'hello!'</code> 这三个值都被包装放在一个tuple里面了。我们也可以使用相反的操作方式，例如：
  </p>
                                                              <p> </p>
                                                              <dl>
                                                              <dd><pre class="verbatim">&gt;&gt;&gt; x, y, z = t<br></pre>
                                                                </dd>
                                                                </dl>
  
                                                                <p> 这个动作叫做打开sequence(
                                                                <i>sequence
unpacking</i> )。Sequence unpacking的动作需要在设定符号左边有一串的变数，其数目应与右边sequence的成员数目相同。值得注意的是，多重设定(a,
b = 1, 2)其实只是tuple packing以及sequence unpacking的结合罢了！   </p>
                                                                <p> 有一个不太对称的地方：packing的动作永远结果是一个tuple，但是unpacking可以针对各种不同的sequence来做。
   </p>
                                                                <p>  </p>
                                                                <h1> <br>
 5.4 Dictionaries(字典)   </h1>
  
                                                                <p> 另外一个在Python当中很好用的内建资料型态是字典(
                                                                <i>dictionary</i>
 )。Dictionary有的时候在别的程式语言里面也叫做连结记忆( ``associative memories'' )或者是连结阵列( ``associative
arrays'' )。不同于sequence是由一连串的数字来做index，dictionary用一个特殊的不可改变的(immutable)钥(
                                                                <i>keys</i>
 来当作其 index。字串及数字都不能被改变，所以都可以来当作dictionary的key。Tuple如果只含有字串，数目字，以及其他tuple的话也可以当作key。如果tuple里面有包含任何可改变的(mutable)的物件的话(包括直接或间接)，就不能当作key来使用。List不能当作key，因为list的成员可以被改变(你可以用
 <tt class="method">append()</tt> 以及 <tt class="method">extend()</tt> 之类的方法，或是切割(slicing)
或 index 来设定list的个别成员)。   </p>
                                                                <p> 我们最好把dictionary想像成一个没有顺序的
 <i>key: value</i> 成对的组合。唯一的条件是，在dictionary里面key的值必须是唯一不重复的。最简单的dictionary就是一对空的中括弧：
                                                                <code>{}</code>
 。在中括弧里面放入由逗号分开的key:value对，就成了dictionary里面的成员。这也是当dictionary被印到输出时的标准格式。
  </p>
                                                                <p> 我们可以对dictionary做一些事，包括加入一个带有key的值、或者是用key来找一个特殊的值。我们也可以用
                                                                <code>del</code>
 来删去一对key:value的成员。如果你试图存一对key:value但是这个key已经被使用了的话，原来的那一个value的值就会被盖过。如果你想用一个不存在的key来找出某一个成员的话，你会得到一个error。
  </p>
                                                                <p> 使用 <code>
keys()</code> 这一个dictionary的方法我们可以得到一个由所有的key值组成的list，其顺序是随机没有次序的(如果你想要排序的话，只要针对这一个得到的list来呼叫其
                                                                <code>sort()</code>
 方法就可以了)。要检查某个key是不是存在的话，你可以使用  <code>has_key()</code> 这一个method来做检查。   </p>
                                                                <p> 底下是一个有关dictionary的小例子：
  </p>
                                                                <p> </p>
                                                                <dl>
                                                                <dd><pre class="verbatim">&gt;&gt;&gt; tel = {'jack': 4098, 'sape': 4139}<br>&gt;&gt;&gt; tel['guido'] = 4127<br>&gt;&gt;&gt; tel<br>{'sape': 4139, 'guido': 4127, 'jack': 4098}<br>&gt;&gt;&gt; tel['jack']<br>4098<br>&gt;&gt;&gt; del tel['sape']<br>&gt;&gt;&gt; tel['irv'] = 4127<br>&gt;&gt;&gt; tel<br>{'guido': 4127, 'irv': 4127, 'jack': 4098}<br>&gt;&gt;&gt; tel.keys()<br>['guido', 'irv', 'jack']<br>&gt;&gt;&gt; tel.has_key('guido')<br>1<br></pre>
                                                                  </dd>
                                                                  </dl>
  
                                                                  <p>  </p>
                                                                  <h1> <br>
 5.5 条件(续)   </h1>
  
                                                                  <p> 在之前所谈到的
                                                                  <code>while</code>
 及 <code>if</code> 里面的条件叙述，除了一般的比较之外也可以包含其他的运算。   </p>
                                                                  <p> 我们可以用
                                                                  <code>in</code>
 以及 <code>not in</code> 来检查某个值是否出现(或没出现)在某个sequence里面。我们也可以使用 <code>is</code>
 以及  <code>is not</code> 来检查两个物件是否事实上指的是相同的一个物件(这只有跟像是list一样可变的物件有关)。所有的比较运算的运算优先次序都是一样的，都比所有的数字运算要来的低。
  </p>
                                                                  <p> 比较运算是可以连起来的：像是
                                                                  <code>a
&lt; b == c</code> 就是试验是否 <code>a</code> 比  <code>b</code> 小，以及 <code>b</code>
 和 <code>c</code> 是否相等。   </p>
                                                                  <p> 比较运算也可以用
                                                                  <code>and</code>
 以及  <code>or</code> 等boolean运算来连结起来，其比较的结果(或其他boolean运算的结果)也可以用 <code>not</code>
 来得到相反(negated)的结果。在这些运算里， <code>not</code> 有最高的优先次序， <code>or</code> 的优先次序最低，但是它们所有的优先次序都比比较运算来的低。所以，
 <code>A and not B or C</code> 其实相等于  <code>(A and (not B)) or C</code> 。当然，最好适时的使用括弧来帮助你表达你真正想要的组合。
  </p>
                                                                  <p> <code>
and</code> 以及 <code>or</code> 这两个boolean运算元也可以称做有捷径的运算元(  <i>shortcut</i>
 operators)：它们的evaluated的次序都是由左而右，而且一但已经可以决定其运算的结果，就不会再继续的做下去。也就是说如果 <code>
A</code> 以及 <code>C</code> 都是 true 而  <code>B</code> 是false的话，  <code>A and
B and C</code> 并不会evaluate C 这个expression。一般来说这些shortcut operator 的传回值如果不是当作boolean而是当作一般的值来用的话，其传回值会是最后一个被evaluate的expression的值。
  </p>
                                                                  <p> 我们也可以把一个比较运算，或是
boolean运算的结果设定给一个变数，其例子如下：   </p>
                                                                  <p> </p>
                                                                  <dl>
                                                                  <dd><pre class="verbatim">&gt;&gt;&gt; string1, string2, string3 = '', 'Trondheim', 'Hammer Dance'<br>&gt;&gt;&gt; non_null = string1 or string2 or string3<br>&gt;&gt;&gt; non_null<br>'Trondheim'<br></pre>
                                                                    </dd>
                                                                    </dl>
  
                                                                    <p> 值得注意的是不像是C，在Python里面设定(assignment)不能够放在expression里面。C的程式设计师也许会针对此点抱怨，但是这样的好处是可以避免一些常见的把设定(
                                                                    <code>
=</code> )及等于(  <code>==</code> )弄混淆的情形  </p>
                                                                    <p>  </p>
                                                                    <h1> <br>
 5.6 Sequences(有序列)及其他资料型态的比较  </h1>
  
                                                                    <p> Sequence
物件可以和其他的相同资料型态的sequence 物件相比较，其比较方法是依照所谓的 <i>lexicographical</i> 顺序(lexicographical
ordering)。首先是两个sequence的第一个成员互相比较，如果比较有大小之别的话就此决定其相对大小，若是相等的话就再比较下一个成员的大小，余此类推直到sequence的结束。如果两个要相比较的成员本身也是一个sequence的话，同样的条件可以继续递回的使用在这两个sequence之上。如果这两个sequence的所有成员都相等的话，我们就说这两个成员是相等的。如果某一个sequence是另一个sequence的一部份的话，较短的那一个sequence就是较小的。字串的Lexicographical顺序用的是个别字元的ASCII码的顺序。底下是一些同一资料型态的sequence的比较例子：
  </p>
                                                                    <p> </p>
                                                                    <dl>
                                                                    <dd><pre class="verbatim">(1, 2, 3)              &lt; (1, 2, 4)<br>[1, 2, 3]              &lt; [1, 2, 4]<br>'ABC' &lt; 'C' &lt; 'Pascal' &lt; 'Python'<br>(1, 2, 3, 4)           &lt; (1, 2, 4)<br>(1, 2)                 &lt; (1, 2, -1)<br>(1, 2, 3)             == (1.0, 2.0, 3.0)<br>(1, 2, ('aa', 'ab'))   &lt; (1, 2, ('abc', 'a'), 4)<br></pre>
                                                                      </dd>
                                                                      </dl>
  
                                                                      <p>
 值得注意的是，我们也可以 比较两个不同资料型态的物件，而其结果是依其资料型态的名称来决定的。所以所有的list都比字串还要来的小(因为list小于string)，所有的string也都比tuple还要小。至于数值的资料型态则是由其数值大小来决定其大小，所以0等于0.0的，其余按此类推。
                                                                      <a name="tex2html3" href="#foot607"><sup>
5.1</sup></a> </p>
                                                                      <p>
 <br>
                                                                      </p>
                                                                      <hr>
                                                                      <h4>
Footnotes</h4>
 
                                                                      <dl>
                                                                      <dt><a name="foot607">
... 其余按此类推。</a><a name="foot607" href="node7.html#tex2html3"><sup>5.1</sup></a>
 </dt>
                                                                        <dd>
         你不应该完全倚赖这些比较不同资料型态的规则，因为这些规则是尚未确定的，以后的Python版本也有可能会再做更动。    </dd>
                                                                          </dl>
 
                                                                          <div class="navigation">
                                                                          <table align="Center" width="100%" cellpadding="0" cellspacing="2">
 <tbody>
                                                                              <tr>
 <td><a href="node6.html"><img src="../icons/previous.gif" border="0" height="32" alt="Previous Page" width="32"></a></td>
 <td><a href="tut.html"><img src="../icons/up.gif" border="0" height="32" alt="Up One Level" width="32"></a></td>
 <td><a href="node8.html"><img src="../icons/next.gif" border="0" height="32" alt="Next Page" width="32"></a></td>
 <td align="Center" width="100%">Python 教学文件</td>
 <td><a href="node2.html"><img src="../icons/contents.gif" border="0" height="32" alt="Contents" width="32"></a></td>
 <td><img src="../icons/blank.gif" border="0" height="32" alt="" width="32"></td>
 <td><img src="../icons/blank.gif" border="0" height="32" alt="" width="32"></td>
 </tr>
                                                                            </tbody>
                                                                          </table>
 <b class="navlabel">Previous:</b> <a class="sectref" href="node6.html">4.
更多流程控制的工具</a> <b class="navlabel">Up:</b> <a class="sectref" href="tut.html">
Python 教学文件</a> <b class="navlabel">Next:</b> <a class="sectref" href="node8.html">
6. 模组(module)</a> <br>
                                                                          <hr></div>
 <!--End of Navigation Panel--> 
                                                                          <address>
 </address>
                                                                          <hr>
请看<i><a href="about.html">关于此文件&hellip;</a></i> 里面有关如何给我们建议的说明。  
                                                                          </body>
                                                                          </html>