边学边看二

本手册中的很多示例都包括注释，甚至有一些在交互提示符中折行。Python中的注释以符号“#”起始，一直到当前行的结尾。注释可能出现在一行的开始，也可能跟在空格或程序代码之后，但不会出现在字符串中，字符串中的#号只代表#号。

示例：

# this is the first comment

SPAM = 1 # and this is the second comment

 # ... and now a third!

STRING = "# This is not a comment."

ps: 简单说明了，注释用＃号，但是注意的是，“注释到当前行结束”

初步认识Python

让我们试验一些简单的Python命令。启动解释器然后等待主提示符“>>> ”出现（这用不了太久）。
3.1.1 数值

解释器的行为就像是一个计算器。你可以向它输入一个表达式，它会返回结果。表达式的语法简明易懂：+，-，*，/和大多数语言中的用法一样（比如C或Pascal），括号用于分组。例如：

>>> 2+2

4

>>> # This is a comment

... 2+2

4

>>> 2+2 # and a comment on the same line as code

4

>>> (50-5*6)/4

5

>>> # Integer division returns the floor:

... 7/3

2

>>> 7/-3

-3

ps ：简单的数学计算，解释语言的好处在于对变量的定义要求不严格

像c一样，等号（“=”）用于给变量赋值。被分配的值是只读的。

>>> width = 20

>>> height = 5*9

>>> width * height

900

ps ：只是只读的。

同一个值可以同时赋给几个变量：

>>> x = y = z = 0 # Zero x, y and z

>>> x

0

>>> y

0

>>> z

0

ps: 右值

Python完全支持浮点数，不同类型的操作数混在一起时，操作符会把整型转化为浮点数。

>>> 3 * 3.75 / 1.5

7.5

>>> 7.0 / 2

3.5

ps ：自动转型

复数也同样得到了支持，虚部由一个后缀“j”或者“J”来表示。带有非零实部的复数记为“(real+imagj)”，或者也可以通过“complex(real, imag)”函数创建。

>>> 1j * 1J

(-1+0j)

>>> 1j * complex(0,1)

(-1+0j)

>>> 3+1j*3

(3+3j)

>>> (3+1j)*3

(9+3j)

>>> (1+2j)/(1+1j)

(1.5+0.5j)

复数总是由实部和虚部两部分浮点数来表示。可能从 z.real和 z.imag 得到复数 z的实部和虚部。

>>> a=1.5+0.5j

>>> a.real

1.5

>>> a.imag

0.5

用于向浮点数和整型转化的函数（float(), int()和 long()）不能对复数起作用－－没有什么方法可以将复数转化为实数。可以使用abs(z)取得它的模，也可以通过z.real得到它的实部。

>>> a=3.0+4.0j

>>> float(a)

Traceback (most recent call last):

 File "<stdin>", line 1, in ?

TypeError: can't convert complex to float; use e.g. abs(z)

>>> a.real

3.0

>>> a.imag

4.0

>>> abs(a) # sqrt(a.real**2 + a.imag**2)

5.0

>>>

ps ：复数的表示，很少用，所以不毕研究

交互模式下，最近一次表达式输出保存在_变量中。这意味着把Python当做桌面计算器使用时，它可以更容易的进行连续计算，例如：

>>> tax = 12.5 / 100

>>> price = 100.50

>>> price * tax

12.5625

>>> price + _

113.0625

>>> round(_, 2)

113.06

>>>

这个变量对于用户来说是只读的。不要试图去给它赋值－－由于Python的语法效果，你只会创建一个同名的局部变量覆盖它。

ps ：_ 变量相当于缓存变量，这个变量只读。

字符串

除了数值，Python还可以通过几种不同的方法操作字符串。字符串用单引号或双引号标识：

>>> 'spam eggs'

'spam eggs'

>>> 'doesn\'t'

"doesn't"

>>> "doesn't"

"doesn't"

>>> '"Yes," he said.'

'"Yes," he said.'

>>> "\"Yes,\" he said."

'"Yes," he said.'

>>> '"Isn\'t," she said.'

'"Isn\'t," she said.'

ps ：单引号和双引号一样，不过在串中，要用\ 转义

字符串可以通过几种方式分行。可以在行加反斜杠做为继续符，这表示下一行是当前行的逻辑沿续。

hello = "This is a rather long string containing\n\

several lines of text just as you would do in C.\n\

 Note that whitespace at the beginning of the line is\

 significant."

print hello

注意换行用 \n 来表示；反斜杠后面的新行标识（newline，缩写“n”）会转换为换行符，示例会按如下格式打印：

This is a rather long string containing

several lines of text just as you would do in C.

 Note that whitespace at the beginning of the line is significant.

ps ：加\ 为接行，加\n 为换行。

然而，如果我们创建一个“raw”行，\n序列就不会转为换行，示例源码最后的反斜杠和换行符n都会做为字符串中的数据处理。如下所示：

hello = r"This is a rather long string containing\n\

several lines of text much as you would do in C."

print hello

会打印为：

This is a rather long string containing\n\

several lines of text much as you would do in C.

ps ：加上r 以后，制表符全部失效了

print """

Usage: thingy [OPTIONS] 

 -h  Display this usage message

 -H hostname Hostname to connect to

"""

produces the following output:

Usage: thingy [OPTIONS] 

 -h Display this usage message

 -H hostname Hostname to connect to

解释器打印出来的字符串与它们输入的形式完全相同：内部的引号，用反斜杠标识的引号和各种怪字符，都精确的显示出来。如果字符串中包含单引号，不包含双引号，可以用双引号引用它，反之可以用单引号。（后面介绍的print语句，可以可以用来写没有引号和反斜杠的字符串）。

ps ：忽略所有的符号，在””” ____ “”””””” 之间的所有字符全部打印

字符串可以用+号联接（或者说粘合），也可以用*号循环。

>>> word = 'Help' + 'A'

>>> word

'HelpA'

>>> '<' + word*5 + '>'

'<HelpAHelpAHelpAHelpAHelpA>'

ps ：字符粘合，类似于java

两个字符串值之间的联接是自动的，上例第一行可以写成“word = 'Help' 'A'”这种方式只对字符串值有效，任何字符串表达式都不适用这种方法。

>>> import string

>>> 'str' 'ing' # <- This is ok

'string'

>>> string.strip('str') + 'ing' # <- This is ok

'string'

>>> string.strip('str') 'ing' # <- This is invalid

 File "<stdin>", line 1, in ?

 string.strip('str') 'ing'

 ^

SyntaxError: invalid syntax

ps ：自动粘合，可以用于字符串的初始化，但是不能用在表达式，这和c 的数组不能动态分配一样。

字符串可以用下标（索引）查询；就像C一样，字符串的第一个字符下标是0。这里没有独立的字符类型，字符仅仅是大小为一的字符串。就像在Icon中那样，字符串的子串可以通过切片标志来表示：两个由冒号隔开的索引。

>>> word[4]

'A'

>>> word[0:2]

'He'

>>> word[2:4]

'lp'

切片索引可以使用默认值；省略前一个索引表示0，省略后一个索引表示被切片的字符串的长度。

>>> word[:2] # The first two characters

'He'

>>> word[2:] # All but the first two characters

'lpA'

ps ：切片，我实在佩服它对字符串的处理能力，这个东西真的太列害了。

和C字符串不同，Python字符串不能改写。按字符串索引赋值会产生错误。

>>> word[0] = 'x'

Traceback (most recent call last):

 File "<stdin>", line 1, in ?

TypeError: object doesn't support item assignment

>>> word[:1] = 'Splat'

Traceback (most recent call last):

 File "<stdin>", line 1, in ?

TypeError: object doesn't support slice assignment

然而，可以通过简单有效的组合方式生成新的字符串：

>>> 'x' + word[1:]

'xelpA'

>>> 'Splat' + word[4]

'SplatA'

ps ：不能对字符串改写，但是可以用切片间接的构造新的字符串。

切片操作有一个很有用的不变性： s[:i] + s[i:] 等于s 。

>>> word[:2] + word[2:]

'HelpA'

>>> word[:3] + word[3:]

'HelpA'

ps ：细想还就是这么回事。

退化的切片索引被处理的很优美：过大的索引代替为字符串大小，下界比上界大的返回空字符串。

>>> word[1:100]

'elpA'

>>> word[10:]

''

>>> word[2:1]

''

ps ：越来越列害了，不会有溢出的问题。

索引可以是负数，计数从右边开始，例如：

>>> word[-1] # The last character

'A'

>>> word[-2] # The last-but-one character

'p'

>>> word[-2:] # The last two characters

'pA'

>>> word[:-2] # All but the last two characters

'Hel'

不过-0还是0，所以它不是从右边计数的！

>>> word[-0] # (since -0 equals 0)

'H'

ps ：从右边起，有：的就是开始到全部，没有的单纯提取

越界的负切片索引会被截断，不过不要尝试在前元素索引（非切片的）中这样做：

>>> word[-100:]

'HelpA'

>>> word[-10] # error

Traceback (most recent call last):

 File "<stdin>", line 1, in ?

IndexError: string index out of range

ps ：可以负溢出切片，但是不可以越界数组。

理解切片的最好方式是把索引视为两个字符之间的点，第一个字符的左边是0，字符串中第n个字符的右边是索引n，例如：

 +---+---+---+---+---+ 

 | H | e | l | p | A |

 +---+---+---+---+---+ 

 0 1 2 3 4 5 

-5 -4 -3 -2 -1

第一行是字符串中给定的0到5各个索引的位置，第二行是对应的负索引。从i到j的切片由这两个标志之间的字符组成。

对于非负索引，切片长度就是两索引的差。例如，word[1:3]的长度是2。

内置函数 len()返回字符串长度：

>>> s = 'supercalifragilisticexpialidocious'

>>> len(s)

34

ps ：一般的字符串处理也就是上边的这些，在java 中，这些功能都被归为了String 类的方法了，也就是全部的函数，但是python 用切片，和索引解决了这个问题，是语言很简洁，也变得很简单。

Unicode 字符串

从Python2.0开始，程序员们可以使用一种新的数据类型来存储文本数据：Unicode 对象。它可以用于存储多种Unicode数据（请参阅 http://www.unicode.org/ ），并且，通过必要时的自动转换，它可以与现有的字符串对象良好的结合。

Unicode针对现代和旧式的文本中所有的字符提供了一个序列。以前，字符只能使用256个序号，文本通常通过绑定代码页来与字符映射。这很容易导致混乱，特别是软件的国际化（internationalization－－通常写做“i18n”－－“i”+18 characters +“n”）。Unicode通过为所有字符定义一个统一的代码页解决了这个问题。

ps ：解释一下，是I 后面有18 个字母，所以叫i18n

Python中定义一个Unicode字符串和定义一个普通字符串一样简单：

>>> u'Hello World !'

u'Hello World !'

引号前小写的“u”表示这里创建的是一个Unicode字符串。如果你想加入一个特殊字符，可以使用Python的 Unicode-Escape 编码。如下例所示：

>>> u'Hello\u0020World !'

u'Hello World !'

被替换的 \u0020标识表示在给定位置插入编码值为 0x0020 的 Unicode字符（空格符）。

ps: 特殊字符可以用码表示

其它字符也会被直接解释成对应的Unicode码。如果你有一个在西方国家常用的Latin-1编码字符串，你可以发现Unicode字符集的前256个字符与Lation-1的对应字符编码完全相同。

ps ：兼容

另外，有一种与普通字符串相同的行模式。想要使用Python的Raw-Unicode-Escape 编码，你需要在字符串的引号前加上 ur 前缀。如果在小写“u”前可能有不止一个反斜杠，它只会把那些单独的 \uXXXX 转化为Unicode字符。

>>> ur'Hello\u0020World !'

u'Hello World !'

>>> ur'Hello\\u0020World !'

u'Hello\\\\u0020World !'

行模式在你需要输入很多个反斜杠时很有用，可能会用于正规表达式。

内置函数unicode() 提供了访问（编码和解码）所有已注册的Unicode编码的方法。它能转换众所周知的 Latin-1, ASCII, UTF-8, 和 UTF-16。后面的两个可变长编码字符集用一个或多个byte存储Unicode字符。默认的字符集是 ASCII ，它只处理0到127的编码，拒绝其它的字符并返回一个错误。当一个Unicode字符串被打印、写入文件或通过str()转化时，它们被替换为默认的编码。

>>> u"abc"

u'abc'

>>> str(u"abc")

'abc'

>>> u"äöü"

u'\xe4\xf6\xfc'

>>> str(u"äöü")

Traceback (most recent call last):

 File "<stdin>", line 1, in ?

UnicodeEncodeError: 'ascii' codec can't encode characters in position 0-2: ordinal not in range(128)

ps ：注意编码的问题，这个是很重要的。

链表

Python 已经有了几个复合数据类型，用于组织其它的值。最通用的是链表，它写为中括之间用逗号分隔的一列值（子项），链表的子项不一定是同一类型的值。

>>> a = ['spam', 'eggs', 100, 1234]

>>> a

['spam', 'eggs', 100, 1234]

ps ：呵呵，这个就不用我数组遍历了，感谢上帝

像字符串一样，链表也以零开始，可以被切片，联接，等等：

>>> a[0]

'spam'

>>> a[3]

1234

>>> a[-2]

100

>>> a[1:-1]

['eggs', 100]

>>> a[:2] + ['bacon', 2*2]

['spam', 'eggs', 'bacon', 4]

>>> 3*a[:3] + ['Boe!']

['spam', 'eggs', 100, 'spam', 'eggs', 100, 'spam', 'eggs', 100, 'Boe!']

ps：注意篮字部分，可以在切片中运算，还可以对切片本身运算，>>> 3*a[:3] + ['Boe!']

表示，要有3 个切片，加上一个boe 。

与不变的字符串不同，链表可以改变每个独立元素的值：

>>> a

['spam', 'eggs', 100, 1234]

>>> a[2] = a[2] + 23

>>> a

['spam', 'eggs', 123, 1234]

ps ：可以改变单个链表的独立元素，但是字符串不可以。

可以进行切片操作，甚至还可以改变链表的大小：

>>> # Replace some items:

... a[0:2] = [1, 12]

>>> a

[1, 12, 123, 1234]

>>> # Remove some:

... a[0:2] = []

>>> a

[123, 1234]

>>> # Insert some:

... a[1:1] = ['bletch', 'xyzzy']

>>> a

[123, 'bletch', 'xyzzy', 1234]

>>> a[:0] = a # Insert (a copy of) itself at the beginning

>>> a

[123, 'bletch', 'xyzzy', 1234, 123, 'bletch', 'xyzzy', 1234]

ps ：功能强大，有比较简单

内置函数len()也同样可以用于链表：

>>> len(a)

8

它也可以嵌套链表（在链表中创建其它链表），例如：

>>> q = [2, 3]

>>> p = [1, q, 4]

>>> len(p)

3

>>> p[1]

[2, 3]

>>> p[1][0]

2

>>> p[1].append('xtra') # See section 5.1

>>> p

[1, [2, 3, 'xtra'], 4]

>>> q

[2, 3, 'xtra']

注意最后一个例子，p[1]和q实际上指向同一个对象！我们在后面会讲到对象语法。

ps ：嵌套的数组，相当于2 维数组，在数组中，有新的数组，但是这种表示方法我更能接受，因为比java 或者c 的a[][] 的形式好解释。