Python学习笔记1--基础篇--基本原书抄写一遍

 

 

 

1、

安装正常后，按照开始-->程序-->Python-->IDLE(Python GUI)的步骤运行Python集成开发环境（Python  Integrated Development  Environment，IDLE）

按下F1，或选择Help-->Python  Docs，会启动完整的Python文档。

2、交互式解释器

解释器的准确外观和错误信息取决于所使用的版本。

若熟悉其他计算机语言，可能会习惯于每行以分号结束。Python则不痛，一行就是一行，不管多少。若喜欢的话，可加上分号，但不会有任何作用（除非同一行还有更多的代码），而且这也不是通行的做法。

 

>>>符号即提示符，可以在后面写点什么，比如print “Hello，world！”。若按下回车，Python解释器会打印出“Hello，world!”字符串，下一行又会出现一个新的提示符。

 

若写点完全不一样的内容呢？

如>>>The Spanish   Inquisition

SyntaxError：invalid syntax

>>>

显然，解释器不明白输入的内容（若使用其他解释器而不是IDLE，比如linux的命令行版本，错误信息会略有不同）。解释器能够指出什么地方错了：它会在“Spanish”这个单词上加上红色背景进行强调（在命令行版本中，则使用符号^来指明）。

   

想要提示的话，可以在提示符后输入help然后按回车。

 

3、算法

食谱和算法都包括一些要素（对象、物品），以及指令（语句）。本例中，“SPAM”和“鸡蛋”就是要素，指令则包括添加SPAM、按照给定时间烹调，等等。接下来先从一些非常简单的Python要素开始，看看能用它们做些什么。

 

4、数字和表达式

交互式Python解释器可以当作非常强大的计算器使用，试试以下的例子：

>>> 2+2

解释器会得出答案为4。

诚然，以上是非常普通的功能。假定读者曾经用过计算器，知道1+2*3和（1+2）*3的区别。在绝大多数情况下，常用算术运算符的功能和计算器的相同。这里有个潜在的陷阱，就是整数除法（在3.0版本之前的Python是这样的）。

>>> 1/2

0

发生了什么？ 一个整数（无小数部分的数）被另外一个整数除，计算结果的小数部分被截除了，只留下整数部分。有些时候，这个功能很有用，但通常情况只需要普通的除法。那么要怎么做呢？这里提供两个有效的解决方案：要用实数（包含小数点的十进制数）而不是整数进行运算，或者让Python改变除法的执行方式。

      实数在Python中被称为浮点数（Float，或者Float-point Number），若参与除法的两个数中有一个数为浮点数，结果亦为浮点数：

>>> 1.0/2.0

0.5

 

>>>1/2.0

0.5

>>>1.0/2

0.5

 

>>>1/2.

0.5

若希望Python只执行普通的除法，那么可以在程序前加上以下语句，或者直接在解释器里面执行它：

>>>from _future_ import  division

 

注意：__future__是个模块，所以它的前后都有个空格。from __future__ import division 这才是正确的写法，另future前后的下划线实际都是两条下划线组成。

 

若通过命令行运行Python，可以使用命令开关-Qnew。通过使用上述两种方法，除法都会变得更为合理：

>>1/2

0.5

 

单斜线不再用作整除，但Python提供了另外一个用作实现整除的操作符---双斜线：

>>>1//2

0

 

就算是浮点数，双斜线也会执行整除：

>>>1.0//2.0

0.0

 

现在，已经了解了基本的算术运算符了（加、减、乘、除）。此外，还有一个非常有用的运算符：

>>>1%2

1

这是取余（模除）运算符----x%y的结果为x除以y的余数。

>>>10/3

3

>>>10%3

1

 

>>>9/3

3

>>>9%3

0

>>> 2.75%0.5

0.25

 

最后一个运算符是幂（乘方）运算符：

>>>2**3

8

>>>-3**2

-9

>>>(-3)**2

9

 

注意：幂运算符比取反（一元减运算符）的优先级要高，所以-3**2等同于-（3**2）。若想计算（-3）**2，就需要显式说明。

 

4、长整型数

    Python可以处理非常大的整数：

>>> 1000000000000000000

10000000000000000000L

Enter后，数字后面加多了个L

 

注意：若使用2.2版本以前的Python，会看到如下的情况：

>>> 1000000000000000000

OverflowError：integer literal   too large

新版本的Python在处理大数时更加灵活。

 

普通整数不能大于 2 147 483 647（也不能小于-2 147 483 648），若真的需要大数，可以使用长整型数。长整型数书写方法和普通整数一样，但结尾有个L。（理论上，用小写的l也可以，但它看起来太像数字1，所以建议不要用小写l。）

 

   在前面的例子中，Python把整数转换为了长整型数，但读者也可以自己完成。我们再来试试这个大数：

>>> 1000000000000000000L

10000000000000000000L

当然，这只是在不能处理大数的旧版本Python中很有用。

那么能不能对那些庞大的数字进行运算呢？当然可以：

>>> 1987163987163981639186L * 198763981726391826L +23

394976626432005567613000143784791693659L

 

如结果所示，长整型数和普通整数可以混合使用。在绝大多数情况下，不用担心长整型数和整数的区别，除非需要进行类型检查。

 

1.4.2 十六进制和八进制

    十六进制数应该像下面这样写：

 >>> 0xAF

 175

 

      八进制数则是：

  >>>010

   8

  首数字都是0

注意：有关Python数值类型和操作符的总结，参见附录B。

 

1.5  变量

     变量基本上就是代表（或者引用）某值的名字。举例来说，若希望用x代表3，只需执行下面的语句即可

>>>x =3

    在使用变量之前，需要对其赋值。

注意：变量名可以包括字母、数字和下划线（_）。变量不能以数字开头，所以Plan9是合法变量，而9Plan不是。

 

1.6 语句

 表达式是某事，而语句是做某事。比如2*2是4，而Print 2*2打印4。那么区别在哪儿呢？

>>> 2*2

 4

>>> print 2*2

 

若在交互式解释器中执行上述两行代码，结果都是一样的。但这只是因为解释器总是把所有表达式的值打印出来而已（都使用了相同的repr函数对结果进行呈现）。

一般情况下，Python并不会那样做。在本章后面，会看到如何抛开交互式提示符来编程，而在程序中编写类似2*2这样的表达式并不能做什么有趣的事情。另外一方面，编写print 2*2则会打印出4。

 

注意：在Python3.0中，print是函数，这意味着需要编写print(42)而不是print  42。此外，它的工作方式和语句差不多，如前文所述。

 

变量就像临时的“存储器”（就像厨房中的锅碗瓢盆一样），它的强大之处在于，在操作变量的时候并不需要知道它存储了什么值。

注意临时存储器一词的引号。值并没有保存在变量中--它们保存在计算机内存的深处，被变量引用。随着本书内容的深入，你会对此越来越清楚：多个变量可以引用同一个值。

 

                                                                                                               --------------------------------- 2014/1/16 上午

 

1.7   获取用户输入

我们通常编写程序让别人用，我们无法预测用户会给程序提供什么值。那么看看非常有用的input函数吧：

>>> input("The meaning of life： ")

The meaning of  life:42

42

 在这里，交互解释器执行了第一行的input(...)语句。它打印出了字符串“The meaning of life: ”并以此作为新的提示符，我输入了42然后按下回车。input语句的结果值就是我输入的数字，它自动在最后一行被打印出来。这个例子确实不太有用，但是请接着看下面的内容：

>>> x = input ("x: ")

x:34

>>> y =input ("y: ")

y:42

>>> print x*y

1428

Python提示符（>>>）后面的语句可以算作一个完整程序的组成部分了，输入的值（34和42）由用户提供，而程序机会打印输出输入的两个数的乘积1428。在编写程序的时候，并不需要知道用户输入的数是多少。

 

注意：你可以将程序存为单独的文件，以便让其他用户可以直接执行。这样的做法是非常有用的。本章后面的“保存并执行程序”部分将会介绍如何实现。

 

if语句，可以绕过程序在给定条件为真的情况下执行某些操作（执行另外的语句），一类条件是使用相等运算符-----进行的相等性测试。是的，是两个等号。一个等号是用来赋值的。

 

可以简单地把这个条件放在if后面，然后用冒号将其和后面的语句隔开：

>>> if  1==2： print 'One equals two'

...

>>> if  1=1： print  ‘One equals one’

...

One equals one

>>>

可以看到，当条件为假的时候，什么都没发生；当条件为真的时候，后面的语句（本例中为print语句）被执行。注意：若在交互式解释器内使用if语句，需要按两次回车，if语句才能执行。（第5章会对其进行说明--现在不必担心）。

 

所以，若变量time绑定到当前时间的分钟数上，那么可以使用下面的语句检查是不是“到了整点”。

if time%60 ==0: print 'On the hour!'

 

1.8 函数

在1.4节中曾经介绍过使用幂运算符（**）来计算乘方。事实上，可以用函数来代替运算符，这个函数就是pow：

>>>2**3

8

>>>pow(2,3)

8

     函数就像可以用来实现特定功能的小程序一样。Python的很多函数都能做很奇妙的事情。事实上，也可以自己定义函数。因此我们通常会把pow等标准函数称为内建函数。

     上例中我使用函数的方式叫作调用函数。可以给它提供参数（本例中国的2和3），它会返回值给用户。因为它返回了值，函数调用也可以简单看作另外一类表达式，就像前面讨论的算数表达式一样。事实上，可以结合使用函数调用和运算符来创建更复杂的表达式：

 

>>> 10+pow(2,3*5)/3.0

10932.666666666666

注意：小数点后的位数会因使用的Python版本的不同而有所区别。

 

还有很多这样的内建函数可以用于数值表达式。比如使用abs函数可以得到数的绝对值，round函数则会把浮点数四舍五入为最接近的整数值：

>>> abs(-10)

10

>>>1/2

0

>>>round(1.0/2.0)

1.0

>>>round(1/2)

0.0

此处1/2=0，跟数据类型有关系，只会得到整数部分，所以round(1/2)也会得到0.0

 

注意：最后两个表达式的区别。整数除法总是会截除结果的小数部分，而round函数则会将结果四舍五入为最接近的整数。但是若想将给定的数值向下取整为某个特定的整数呢？

比如一个人的年龄是32.9岁----但是想把它取整为32，因为她还没到33岁。Python有实现这样功能的函数（称为floor）,单丝不能直接使用它。与其他很多有用的函数一样，你可以在某个模块中找到floor函数。

 

1.9 模块

 

    可以把模块想象成导入到Python以增强其功能的扩展。需要使用特殊的命令import来导入模块。前面内容提到的floor函数就在名为math的模块中：

>>> import math

>>> math.floor(32.9)

32.0

注意它是怎么起作用的：用import导入了模块，然后按照“模块.函数”的格式使用这个模块的函数。

    若想把年龄转换为整数（32）而不是浮点数（32.0），可以使用int函数。

>>>int(math.floor(32.9))

32

注意：还有类似的函数可以将输入数转换为其他类型（如long和float）。事实上，它们并不完全是普通的函数----它们是类型对象（type object）。后面，我将会对类型进行详述。与floor相对的函数是ceil（ceiling的简写），可以将给定的数值转换成为大于或等于它的最小整数。

 

在确定自己不会导入多个同名函数（从不同模块导入）的情况下，你可能不希望在每次调用函数的时候，都要写上模块的名字。那么，可以使用import命令的另外一种形式：

>>>from  math import  sqrt

>>> sqrt(9)

3.0

 

在使用了“from 模块import函数”这种形式的import命令之后哦，就可以直接使用函数，而不需要模块名作为前缀。

 

提示：事实上，以使用变量来引用函数（或者Python之中大多数的对象）。比如，通过foo=math.sqrt进行赋值，然后就可以使用foo来计算平方根了：foo(4)的结果为2.0。

 

 

1.9.1  cmath和复数

sqrt函数用于计算一个数的平方根。 看看如果给它一个负数作为参数会如何：

>>> from math import sqrt

>>> sqrt(-1)

Traceback (most recent call last):

     File "", line 1. i ?

         sqrt(-1)

    ValueError:math  domain  error

或者，在其他平台会有以下结果：

   >>>sqrt(-1)

nan

注意： nan是一个特殊值的简写，意思是“not a number” (非数值)。

 

噢，出错是有原因的。不能求负数的平方根----真的不可以吗？ 当然可以：负数的平方根是虚数（这是标准的数学概念--若感觉有些绕不过来，跳过即可）。那么为什么不能使用sqrt？ 因为它只能处理浮点数，而虚数（以及复数，即实数和虚数之和）是安全不同的----这也是由另外一个叫做cmath(即complex math，复数)的模块来实现这些功能的原因。

 

>>> import cmath

>>> cmath.sqrt(-1)

1j

注意，我在这里没有使用from...import...语句。因为一旦使用了这个语句，就没法使用普通的sqrt函数了。如计算sqrt(9)，得出的结果会是（3+0j） 。这类命名冲突很讨厌，因此，除非真的需要from这个形式的模块导入语句，否则应该坚持使用普通的import。

   1j是个虚数，虚数均以j(或者J)结尾，就像长整型数使用L一样。我们再这里不深究复数的理论，只是举最后一个例子，来看一下如何使用复数：

>>> (1+3j)*(9+4j)

(-3+31j)

可以看到，Python语言本身就提供了对复数的支持。

注意：Python中没有单独的虚数类型。它们被看作实数部分为0的复数。

 

1.9.2 回到__future__

    有传言说Guido  van Rossum(Python之父)拥有时光机，以为在人们要求增加语言新特性的时候，这个特性通常都已经实现了。当然，我们是不允许进入这架时光机的。

但是Guido很善良，他将时光机的一部分以__future__这个充满魔力的形式融入了Python。通过它可以导入那些在未来糊成为标准Python组成部分的新特性。你已经在1.4节见识过这个模块了，而在本书余下的部分，你还将与它不期而遇。

 

1.10保存并执行程序

   交互式解释器是Python的强项之一，它让实时检验解决方案并且体验这门语言成为了现实。如果想知道如何使用某些语句，那么就试试看吧！

但是，在交互式解释器里面输入的一切都会在它退出的时候丢失。我们真正想做的事情是编写自己和他人都能运行的程序。在本部分内容中，将会介绍如何实现这一点。

 

   首先，需要一个文本编辑器，最好是专门用来编程的。如果已经在用IDLE，那么很幸运：用File-->New Window方式创建一个新的编辑窗口即可。这样，另一个窗口出现了--没有交互式提示符，哇！

 

   先输入以下内容：

 print "Hello,world!"

  现在选择File-->Save保存程序（其实就是纯文本文件）。要确保将程序保存在一个以后能找到的地方。最后，要为自己的程序文件起个有意义的名字，比如hello.py，其中，以.py结尾是很重要的。

 

 先别关闭包含程序的窗口，如果已经关了，那么再打开它（File-->Open）。现在应该能用Run-->Modules或者按下Ctrl+F5键来运行程序了（如果没有使用IDLE，请查看下一节有关如何在命令提示符下运行程序的内容。）

 

发生了什么？ Hello，world！在解释器窗口内打印出来了，这就是想要的结果。解释器提示符没了（不同的版本会有所差异），但是可以按下回车键将它找回来（在解释器窗口中按下回车键）。

 

接下来，我们对上述脚本进行扩展，如下例所示：

   name = raw_input ("What is your name? ")

  print "Hello, " + name + "!"

 

不要担心，input 和raw_input的区别--稍后，我会进行介绍的。

 

如果运行这个程序（记得先保存），应该会在解释器窗口中看到下面的提示：

What is your name?

输入你的名字（比如ning），然后按下回车键。你将会看到如下内容：

Hello，ning!

这是不是很有趣？

 

1.10.1   通过命令提示符运行Python脚本

  事实上，运行程序的方法有很多。首先，假定打开了DOS窗口或者Unix中的Shell提示符，并且进入了某个包含Python可执行文件（在Windows中是python.exe，而Unix中则是python）的目录，或者包含了这个可执行文件的目录已经放置在环境变量PATH中了（仅适用于Windows）。同时假设，上一节的脚本文件（hello.py）也在当前的目录中。那么，可以在Windows中使用以下命令执行的脚本：

C：\>python hello.py

或者在UNIX下：

$ python hello.y

可以看到，命令是一样的，仅仅是系统提示符不同。

 

注意：如果不想跟什么环境变量打交道，可以直接自定Python解释器的完整路径。在Windows中，可以通过以下命令完成操作：

C：\>C:\Python25\python hello.py

 

1.10.2  让脚本像普通程序一样运行

   有些时候希望像运行其他程序（比如Web浏览器、文本编辑器）一样运行Python程序（也叫做脚本），而不需要显式使用Python解释器。在UNIX中有个标准的实现方法：

在脚本前面加上#！（叫做pound bang 或者shebang），在其后加上用于解释脚本的程序的绝对路径（在这里，用于解释代码的程序是Python）。即使不太明白其中的原理，如果希望自己的代码能够在Unix下顺利执行，那么只要把下面的内容放在脚本的首行即可：

 

    #！/usr/bin/env  python

不管Python二进制文件在哪里，程序都会自动执行。

 

注意：在某些操作系统中，如果安装了最新版本的Python（比如2.5），同时旧版本的Python（比如1.5.2）仍然存在（因为某些系统程序需要它，所以不能把它卸载），那么在这种情况下，/usr/bin/env技巧就不好用了，因为旧版本的Python可能会运行程序。因此需要找到新版本Python可执行文件（可能叫做Python或者Python2）的具体位置，然后在pound bang行中使用完整的路径，如下例所示：

#！/usr/bin/python2

具体的另会因系统而异。

在实际运行脚本之前必须让脚本文件具有可执行 属性：

$ chmod a+x hello.py

现在就能这样运行代码了（假设路径就是当前目录）：

$ hello.py

注意如果上述操作不起作用的话，试试./hello.py。即使当前的目录（.）并不是执行路径的一部分，这样的操作也能够成功。

 

如果你喜欢，还可以将文件重新命名，去掉.py扩展名让它看起来更像个普通的程序。

 

双击怎么样

    在Windows系统中，让代码像普通程序一样运行的关键在于口站名.py。试着双击上一节保存好的hello.py文件。如果Python安装正确，那么，一个DOS窗口 就会出现，里面有“What is your name”提示，很酷吧？（稍后将看到如何使用按钮、菜单等让程序看起来更棒。）

    然而，像这样运行程序可能会碰到一个问题：程序运行完毕，窗口也跟着关闭了。也就是说，输入了名字以后，还没来得及看结果，程序窗口就已经关闭了。试着改改代码，在最后加上以下这行代码：

    raw_input("Press ")

  这样，在运行程序并且输入名字之后，将会出现一个包含以下内容的DOS窗口：

     what is your name? vivi

     Hello, vivi!

     Press

用户按下回车键以后，窗口就会关闭（因为程序运行结束了）。为探索本源，现在把文件改名为hello.pyw(这是Windows专用的文件类型)，像刚才一样双击。发生了什么？什么都没有！怎么会这样呢？本书后面的内容会给出答案----我保证。

 

1.10.3 注释

   井号（#）在Python中有些特殊。在代码中输入它的时候，它右边的一切都会被忽略（这也是之前Python解释器不会被/usr/bin/env行“卡住”的原因了）。比如：

#打印圆的周长：

Print 2*pi*radius

 

                                                                                                 -----------------------2014/1/17

 

1.11字符串

   那么raw_input函数和“Hello."+name+"!”这些内容到底是什么意思？放下raw_input函数暂且不表，先说“Hello”这部分。

  1.11.1  单引号字符串和转义引号

   字符串是值，就像数字一样：

>>>“Hello,world!”

'Hello,world!'

但Python打印出字符串的时候，是用单引号括起来的，但我们再程序中用的是双引号。这有什么区别吗？事实上，没有区别。

>>>'Hello,world!'

'Hello,world!'

用了单引号结果也是一样的。那么为什么两个都可以用呢？

 

举两个例子：

1）

>>>“Let's go!”

"Let's go!"

若用单引号

>>>'Let's go!'

SyntaxError:invalid syntax

会提示语法错误。因为Let前后各有一个撇号，这构成了一个字符串，但Python不知道如何处理该行余下的内容，解释器不能识别。

解决方案：

a)即用双引号将整个字符串括起来。

b)使用反斜线（\）对字符串中的引号进行转义：

>>>'Let\'s go!'

"Let's go!"

Python会明白中间的单引号是字符串中的一个字符，而不是字符串的结束标记（即便如此，Python也会在打印字符串的时候使用双引号）。

 

2）

>>>’ ”Hello，world!“ she said‘

'"Hello,world!" she said'

这个字符串中，橘子包含了双引号。所以，处于上例所述的原因，就需要用单引号把字符串括起来了。

即它的解决方案：

a) 用单引号把字符串括起来；

b)使用反斜线(\)对字符串中的双引号进行转义；

>>>"\"Hello,world!\" she said"

'"Hello,world!" she said'

 

使用转义字符，Python会明白中间的双引号是字符串中的一个字符，而不是字符串的结束标记。

 

像这样转义引号十分有用，有些时候甚至还是必需的。例如，若希望打印一个包含单双引号的字符串，不用反斜线的话怎么办?

比如字符串’Let\'s say "hello，world！"‘

 

注意：在本章后面的内容中，将会介绍通过使用长字符串和原始字符串（两者可以联合使用）来减少绝大多数反斜线的使用。

 

1.11.2 拼接字符串

继续研究上面的例子，我们可以通过另外一种方式输出同样的字符串：

>>> "Let's say" '"Hello,world!"'

'Let\'s say "Hello,world!" '

我只是用一个接着另一个的方式写了两个字符串，Python就会自动拼接它们（将它们合为一个字符串）。这种机制用得不多，有时却非常有用。不过，它只是在同时写下两个字符串时才有效，而且要一个紧接着另一个。

 

>>>x ="Hello, "

>>>y ="world!"

>>> x y

SyntaxError: invalid syntax

换句话说，这仅仅是书写字符串的一种特殊方法，并不是拼接字符串的一般方法。那么，该怎么拼接字符串呢？就像进行加法运算一样：

>>>"Hello， "+”world！“

’Hello，world！‘

>>> x ="Hello, "

>>> y="world!"

>>> x+y

'Hello,world!'

                                                                                                                    ------------------------2014/1/20 下午3点

1.11.3 字符串表示，str和repr

    通过前面的例子读者们可能注意到了，所有通过python打印的字符串还是被引号括起来的。这是因为Python打印值的时候会保持该值在Python代码中的状态，而不是你希望用户所看到的状态。若使用Print语句，结果就不一样了：

     >>>"Hello,world!"                                                 

       'Hello,world!'

     >>> 10000L

       10000L

     >>> print "Hello,world!"

         Hello,world!

     >>> print 10000L

          10000

可以看到，长整型数10000L被转换成了数字10000，而且在显示给用户的时候也如此。但是当你想知道一个变量的值是多少时，可能会对它是整型还是长整型感兴趣。

我们在这里讨论的实际上是值被转换为字符串的两种机制。可以通过以下两个函数来使用两种机制：一个是通过str函数，它会把值转换为合理形式的字符串，以便用户可以理解；而repr会创建一个字符串，它以合法的Python表达式的形式来表示值。下面是一些例子：

事实上，str和int、long一样，是一种类型。而repr仅仅是函数。

 

>>> print repr("Hello,world!")

    'Hello,world!'

>>> print repr(10000L)

     10000L

>>> print str("Hello,world!")

      Hello,world!

>>> print str(10000L)

      10000

 

repr(x)的功能也可以用`X`实现（注意，`是反引号，而不是单引号）。若希望打印一个包含数字的句子，那么反引号就很有用了。比如：

>>>temp =42

>>>print "The temperature is "+temp

Traceback (most recent call last):

     File "",line 1. in?

         print "The temperature is " + temp

TypeError:cannot add type "int" to string

>>>print "The temperature is " + `temp`

 The temperature is 42

 

注意：在Python 3.0中，已经不再使用反引号了。因此，即使在旧的代码中看到了反引号，你也应该坚持使用repr。

第一个print语句不能工作，是因为不可以将字符串和数字进行相加。而第二个则可以正常工作，因为我已经通过反引号将temp的值转换为字符串“42”了。

（当然，通过repr，也可以得到同样结果。但是，使用反引号可能更清楚一些。事实上，也可以在本例中使用str。）

简而言之，str、repr和反引号是将Python值转换为字符串的3种方法。函数str让字符串更易于阅读，而repr(和反引号)则把结果字符串转换为合法的Python表达式。

 

1.11.4  input和raw_input的比较

 在另外一个脚本文件中输入下面的语句：

  name = input （“What is your name?”）

  print “Hello， ”+ name + "!"

这是一个完全合法的程序。但是，一会你就会看到，这样是不可行的。尝试运行该程序：

What is your name? Vivi

 Traceback (most recent call last):

     File "C:/python/test.py",line 2, in ?

         name = input ("What is your name?")

      File "", line 0,in ?

NameError: name 'vivi' is not defined

问题在于input会假设用户输入的是合法的Python表达式（或多或少有些与repr函数相反的意思）。若以字符串作为输入的名字，程序运行是没有问题的：

What is your name? "Vivi"

Hello,Vivi!

然而，要求用户带着引号输入他们的名字有点过分，因此，这就需要使用raw_input函数，它会把所有的输入当作原始数据（raw data），然后将其放入字符串中：

>>> input ("Enter a  number: ")

Enter a number :3

3

>>> raw_input("Enter a number: ")

Enter a number: 3

'3'

除非对input有特别的需要，否则应该尽可能使用raw_input函数。

 

                                                                                     ------------------------------------

 

1.11.5 长字符串、原始字符串和Unicode

   在结束本章之前，还会介绍另外两种书写字符串的方法。在需要长达多行的字符串或者包含多种特殊字符的字符串的时候，这些候选的字符串语法就会非常有用。

1、长字符串

  若需要写一个非常非常长的字符串，它需要跨多行，那么，可以使用三个引号代替普通引号。

print '''This is a very long string.

It continues here.

And it's not over yet.

"Hello,world!"

Still here.'''

也可以使用三个双引号，如"""Like This """。注意因为这种与众不同的引用方式，你可以在字符串之中同时使用单引号和双引号，而不需要使用反斜线进行转义。

 

提示：普通字符串也可以跨行。若一行之中最后一个字符是反斜线，那么，换行符本身就“转义”了，也就是被忽略了。例如：

print "Hello, \

world!"

这句会打印Hello，world！。这个用法也适用于表达式和语句：

>>>1+2+\

            4+5

12

>>>print \

          'Hello,world'

Hello,world

 

2.原始字符串

     

在普通字符串中，反斜线有特殊的作用：它会转义，可以在字符串中加入通常情况下不能直接加入的内容。例如，换行符可以写为\n，

并可放于字符串中，如下所示：

>>>print 'Hello, \nworld!'

Hello,

world!

若希望在字符串中包含反斜线再加上n怎么办呢？

例如，可能需要像DOS路径“C：\nowhere”这样的字符串：

>>> path ='C:\nowhere'

>>>path

'C:\nowhere'

这看起来是正确的，但是，在打印该字符串时就会发现问题了：

>>> print path

C:

owhere

 

这并不是期望的结果，那么该怎么办呢？我可以使用反斜线对其本身进行转义：

>>>print 'C:\\nowhere'

C:\nowhere

 

但是对于长路径，那么可能需要很多反斜线：

path = 'C:\\Program Files \\fnord\\foo\\bar\\baz\\frozz\\bozz'

在这样的情况下，原始字符串就披上用场了。原始字符串不会把反斜线当作特殊字符。在原始字符串中输入的每个字符都会与书写的方式保持一致：

>>> print r 'C:\nowhere'

C:\nowhere

>>> print r 'C:\Program Files\fnord\foo\bar\baz\frozz\bozz'

C:Program Files\fnord\foo\bar\baz\frozz\bozz

自己批注：注意，r和后面的字符串中间无空格，否则会有语法错误。

可以看到，原始字符串以r开头。可以在原始字符串中放入任何字符；

 

但当我们要像平常一样对引号进行转义，最后输出的字符串包含了转义所用的反斜线：

>>> print r'Let\'s go!'

Let\'s go!

 

                                 -----------------------------作者描述的好复杂，所以有些部分，用了自己理解的，整理了。

 

另：不能在原始字符串结尾输入反斜线。换句话说，原始字符串最后的一个字符不能是反斜线，因为Python会不清楚是否应该结束字符串：

 

>>>print r"This is illegal\"

SyntaxError: invalid token

尤其在书写正则表达式时，原始字符串会特别有用。