node5.html

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

                                                </dd>
                                                </dl>
  
                                                <p> <tt class="samp" string[subscprt:subscprt]</tt="">
如果负数index超过字串的范围的话，就自动只会到最大可能的范围，但是如果不是切割一部份的话就会造成错误的情形：   </tt></p>
                                                <p> </p>
                                                <dl>
                                                <dd><pre class="verbatim"><tt class="samp" string[subscprt:subscprt]</tt="">&gt;&gt;&gt; word[-100:]<br>'HelpA'<br>&gt;&gt;&gt; word[-10]    # error<br>Traceback (innermost last):<br>  File "&lt;stdin&gt;", line 1<br>IndexError: string index out of range<br></tt></pre>
                                                  </dd>
                                                  </dl>
  
                                                  <p> <tt class="samp" string[subscprt:subscprt]</tt="">
最好避免错误的方法是把index看成是指向字元及字元间位置的指标，字串的最开头是0，字串的结尾处就是字串的长度。如下图所示：   </tt></p>
                                                  <p> </p>
                                                  <dl>
                                                  <dd><pre class="verbatim"><tt class="samp" string[subscprt:subscprt]</tt=""> +---+---+---+---+---+ <br> | H | e | l | p | A |<br> +---+---+---+---+---+ <br> 0   1   2   3   4   5 <br>-5  -4  -3  -2  -1<br></tt></pre>
                                                    </dd>
                                                    </dl>
  
                                                    <p> <tt class="samp" string[subscprt:subscprt]</tt="">
上图的数字部分第一行代表的是正数的index，由0到字串的长度，第二行代表的是负数的index。字串的切片(slice)很容易就可以看出来，就是两个index之间的所有字元组合成的字串啰。
  </tt></p>
                                                    <p> <tt class="samp" string[subscprt:subscprt]</tt="">
对于正数的index来说，如果两个index都在范围之内，字串的切片(slice)的长度就正好是其两个index相减的结果。举例来说  <code>
word[1:3]</code> 的长度就正好是 2。   </tt></p>
                                                    <p> <tt class="samp" string[subscprt:subscprt]</tt="">
Python内建的 <tt class="function">len()</tt> 函式可以帮助我们得到字串的长度值。   </tt></p>
                                                    <p> </p>
                                                    <dl>
                                                    <dd><pre class="verbatim"><tt class="samp" string[subscprt:subscprt]</tt="">&gt;&gt;&gt; s = 'supercalifragilisticexpialidocious'<br>&gt;&gt;&gt; len(s)<br>34<br></tt></pre>
                                                      </dd>
                                                      </dl>
  
                                                      <p>  </p>
                                                      <h2> <tt class="samp" string[subscprt:subscprt]</tt=""><br>
 3.1.3 Unicode 字串   </tt></h2>
  
                                                      <p> <tt class="samp" string[subscprt:subscprt]</tt="">
从Python 2.0 开始Python支援一种新的储存文字资料的资料型态：Unicode物件(object)。使用这个物件你可以储存并控制Unicode的资料(详见
                                                      <a class="url" href="http://www.unicode.org">
http://www.unicode.org <img src="../icons/offsite.gif" border="0" class="offsitelink" height="15" width="17" alt="[off-site link]"></a>
) ，并且这个物件跟已经存在的字串(string)物件是完全可以互相整合，并且在需要时可以互相转换的。   </tt></p>
                                                      <p> <tt class="samp" string[subscprt:subscprt]</tt="">
使用Unicode的好处是可以处理各种不同国家语言的字元。在Unicode之前，在一个code page里只有256个字元可以使用在script中。这个限制的结果常常造成软体国际化(internationalizetion，通常写作
"<tt class="samp">i18n</tt>" -- "<tt class="character">i</tt>" + 18个字元  +
"<tt class="character">n</tt>")时候的困扰。Unicode的出现定义一个所有script都可以用的code page，如此就解决了这个问题。 
 </tt></p>
                                                      <p> <tt class="samp" string[subscprt:subscprt]</tt="">
在Python中要创造一个Unicode字串就跟创造一个普通字串一样容易：   </tt></p>
                                                      <p> </p>
                                                      <dl>
                                                      <dd><pre class="verbatim"><tt class="samp" string[subscprt:subscprt]</tt="">&gt;&gt;&gt; u'Hello World !'<br>u'Hello World !'<br></tt></pre>
                                                        </dd>
                                                        </dl>
  
                                                        <p> <tt class="samp" string[subscprt:subscprt]</tt="">
在引号之前小写的 "<tt class="character">u</tt>" 代表这个字串是一个Unicode字串。如果你要用到特殊字元，你可能要使用Python的Unicode特殊字元编码( 
                                                        <i>Unicode-Escape</i>
 encoding)。底下的范例示范如何使用之：   </tt></p>
                                                        <p> </p>
                                                        <dl>
                                                        <dd><pre class="verbatim"><tt class="samp" string[subscprt:subscprt]</tt="">&gt;&gt;&gt; u'Hello\\u0020World !'<br>u'Hello World !'<br></tt></pre>
                                                          </dd>
                                                          </dl>
  
                                                          <p> <tt class="samp" string[subscprt:subscprt]</tt="">
上面的 <code> <br>
 u0020</code> 表示在这个位置要插入一个由十六位元0x0020所代表的Unicode字元 (就是空白字元啦)。   </tt></p>
                                                          <p> <tt class="samp" string[subscprt:subscprt]</tt="">
其他的字元也是一样的会被解读为其对应的Unicode字元。由于Unicode对应中的前256 个Unicode字元正好就是大部分欧美国家使用的Latin-1
编码字元，所以其转换是更加的容易。   </tt></p>
                                                          <p> <tt class="samp" string[subscprt:subscprt]</tt="">
对于专家们来说，有一个字串的原始模式(raw mode)可以使用。你必须再加上一个小写 'r' 来使Python 使用这一个原始的Unicode特殊字元编码(
                                                          <i>Raw-Unicode-Escape</i>
 encoding)。只有当  <code> <br>
 uXXXX</code> 之中的小写 'r' 有奇数的'\'时才会用到这一个编码的。  </tt></p>
                                                          <p> </p>
                                                          <dl>
                                                          <dd><pre class="verbatim"><tt class="samp" string[subscprt:subscprt]</tt="">&gt;&gt;&gt; ur'Hello\u0020World !'<br>u'Hello World !'<br>&gt;&gt;&gt; ur'Hello\\u0020World !'<br>u'Hello\\\\u0020World !'<br></tt></pre>
                                                            </dd>
                                                            </dl>
  
                                                            <p> <tt class="samp" string[subscprt:subscprt]</tt="">
这个原始模式(raw mode)通常用在当你的字串里面有一大堆的反斜线 '\' 时 ，例如regular expressions(正规表示)时就常用到。
  </tt></p>
                                                            <p> <tt class="samp" string[subscprt:subscprt]</tt="">
除了这些标准的编码之外， Python还提供了一整套的方法让你可以从以知的编码中创造出Unicode字串来。   </tt></p>
                                                            <p> <tt class="samp" string[subscprt:subscprt]</tt="">
Python内建的 <tt class="function">unicode()</tt> p() 函式可以让你使用所有的已注册的Unicode解码/编码系统(codecs
(COders and DECoders))。 这个 codes 可以与大部分的系统互相转换，包括 <i>Latin-1</i>, <i>ASCII</i>
, <i>UTF-8</i> 以及  <i>UTF-16</i> 等等。上面所提到的最后两种系统是可变长度的编码系统，可以来储存8位元及16位元的Unicode字元。Python预设使用UTF-8为预设编码系统。当你印出Unicode或是将Unicode写入档案时都会使用到。
  </tt></p>
                                                            <p> </p>
                                                            <dl>
                                                            <dd><pre class="verbatim"><tt class="samp" string[subscprt:subscprt]</tt="">&gt;&gt;&gt; u"&auml;&ouml;&uuml;"<br>u'\344\366\374'<br>&gt;&gt;&gt; str(u"&auml;&ouml;&uuml;")<br>'\303\244\303\266\303\274'<br></tt></pre>
                                                              </dd>
                                                              </dl>
  
                                                              <p> <tt class="samp" string[subscprt:subscprt]</tt="">
如果你要使用一个特别的编码系统，但是要印出对应的Unicode码时，你可以使用  <tt class="function">unicode()</tt>
 函式，加上这个编码系统的名称当作第二个参数。   </tt></p>
                                                              <p> </p>
                                                              <dl>
                                                              <dd><pre class="verbatim"><tt class="samp" string[subscprt:subscprt]</tt="">&gt;&gt;&gt; unicode('\303\244\303\266\303\274','UTF-8')<br>u'\344\366\374'<br></tt></pre>
                                                                </dd>
                                                                </dl>
  
                                                                <p> <tt class="samp" string[subscprt:subscprt]</tt="">
如果要把Unicode字串转换为一般的字串编码时，可以使用Unicode物件的 <tt class="method">encode()</tt>
方法(method)。   </tt></p>
                                                                <p> </p>
                                                                <dl>
                                                                <dd><pre class="verbatim"><tt class="samp" string[subscprt:subscprt]</tt="">&gt;&gt;&gt; u"&auml;&ouml;&uuml;".encode('UTF-8')<br>'\303\244\303\266\303\274'<br></tt></pre>
                                                                  </dd>
                                                                  </dl>
  
                                                                  <p>  </p>
                                                                  <h2> <tt class="samp" string[subscprt:subscprt]</tt=""><br>
 3.1.4 列(List)   </tt></h2>
  
                                                                  <p> <tt class="samp" string[subscprt:subscprt]</tt="">
(译：硬要翻译list实在太不方便，我直接用原文啰)  </tt></p>
                                                                  <p> <tt class="samp" string[subscprt:subscprt]</tt="">
Python能够了解一些较为 <i>复杂</i> 的资料型态，这些资料型态大多是用来处理一群的其他资料值。最方便使用的要算是 <i>list</i>
 了，一个list可以写成一串由逗号分开的值(东西)，然后用角括号括起来便成。放在list里的东西不需要是同一个资料型态  </tt></p>
                                                                  <p> </p>
                                                                  <dl>
                                                                  <dd><pre class="verbatim"><tt class="samp" string[subscprt:subscprt]</tt="">&gt;&gt;&gt; a = ['spam', 'eggs', 100, 1234]<br>&gt;&gt;&gt; a<br>['spam', 'eggs', 100, 1234]<br></tt></pre>
                                                                    </dd>
                                                                    </dl>
  
                                                                    <p> <tt class="samp" string[subscprt:subscprt]</tt="">
跟字串的index用法相同，list的index也由0开始，同样你可以用index来切割lists、组合两个list等等：  </tt></p>
                                                                    <p> </p>
                                                                    <dl>
                                                                    <dd><pre class="verbatim"><tt class="samp" string[subscprt:subscprt]</tt="">&gt;&gt;&gt; a[0]<br>'spam'<br>&gt;&gt;&gt; a[3]<br>1234<br>&gt;&gt;&gt; a[-2]<br>100<br>&gt;&gt;&gt; a[1:-1]<br>['eggs', 100]<br>&gt;&gt;&gt; a[:2] + ['bacon', 2*2]<br>['spam', 'eggs', 'bacon', 4]<br>&gt;&gt;&gt; 3*a[:3] + ['Boe!']<br>['spam', 'eggs', 100, 'spam', 'eggs', 100, 'spam', 'eggs', 100, 'Boe!']<br></tt></pre>
                                                                      </dd>
                                                                      </dl>
  
                                                                      <p>
 <tt class="samp" string[subscprt:subscprt]</tt="">与字串不相同的是，字串的个别字元是不可变动的(
                                                                      <i>
immutable</i> )，但是list的个别成员是可以自由改变的。   </tt></p>
                                                                      <p>
 </p>
                                                                      <dl>