Python学习教程（一）——初步认识

一、版本说明

      本学习教程所有代码都是基于Python2.7版本。

二、Python的第一个语句

      根据“国际惯例”，学习一门语言，总要先写一个“Hello World !”，那么来吧：

>>> print "Hello World !"Hello World !

      看起来很简单，print语句打印出了“Hello World !”字符串，与大部分语言相比，我们发现语句结尾并没有加分号（“;”），Python中一行就是一个可执行语句，当然如果我们尝试加上分号也没有关系，并不会看到任何报错，但是这里还是建议不要加上分号。

三、数字运算

      除了上面简单的打印语句外，我们还可以直接进行数学运算操作，然后直接打印出运算结果，比如：

>>> 1+23>>> 4*520>>> 2 * math.pi * 20125.66370614359172>>> 1/20

      math.pi 是π（3.1415926...）。具体导入math的一些用法，后面会涉及到。这里只需要知道，如果要使用math，必须要先写上导入语句：import math。

      最后一个在计算1/2时，为什么会是0呢？这里因为整数除以整数时Python默认把小数点后面的数截掉了，嗯，就是截掉了，没有四舍五入。那如何才能得到我们预期的0.5呢？这里有两种方式：1）转换为用带小数点的实数进行运算；2）设置Python除法的执行方式；

1）转换为用带小数点的实数进行运算：

>>> 1.0/2.00.5>>> 1/2.00.5>>> 1.0/20.5>>> 1./20.5>>> 1/2.0.5>>> 1./2.0.5

以上都是正确的写法，小数点后的0可以不写，但建议还是规范写法便于阅读。

2）设置Python除法的执行方式：

>>> from __future__ import division>>> 1/20.5

或 -Qnew 的方式启动Python：

C:\Users\yangliehui>python -QnewPython 2.7.13 (v2.7.13:a06454b1afa1, Dec 17 2016, 20:53:40) [MSC v.1500 64 bit (AMD64)] on win32Type "help", "copyright", "credits" or "license" for more information.>>> 1/20.5

      在以上两种方式下除号“/”不能实现截取小数点的整除了，但Python提供了一个可以在上述两种方式下实现截取小数并整除的方式——双斜杠： 

>>> 1/20.5>>> 1//20>>> 1.0//2.00.0

      可以看到，使用//，即使是浮点数1.0//2.0也实现了小数点的截取整除； 

      除了上面的几个运算之外，还有取余运算和幂运算，我们这里简单提及一下：
      取余运算——x%y

>>> 10 % 31

      幂运算——x ** y

>>> 2 ** 38

      表示2³。幂运算符的优先级高于取反符号，比如：

>>> -2 ** 2-4>>> (-2) ** 24

四、长整数

      当我们在写一个整数的时候，Python默认会认为是int类型整数，比如：

>>> 10001000

但是，当数字特别大，大到超过int类型的最大长度时，Python就会自动帮我们转为long型。int与long型的具体区别在后面的课程中还会深入的涉及到，这里我们只需要知道，整数类型有int和long，当整数超过int规定的最大长度时就必须要用long类型表示。那么这个int的最大值是多大呢？我们可以用下面的代码查一下：

>>> import sys>>> print sys.maxint2147483647

2147483647就是int的最大值（正好是：2 ^ 31 - 1 = 2147483647），超过这个最大值，Python就会自动帮我们转换为long类型：

>>> 21474836472147483647>>> 21474836482147483648L>>> 2147483647 + 12147483648L

我们看到当整数大于2147483647后，Python输出的整数后面加上了“L”。这里，我们说整数被被动的转换为了long型了，那么我们可不可以主动直接定义一个long型整数呢？看下面的例子：

>>> 100l100L>>> 100L100L>>> 100L * 3300L

从上面的例子看，我们可以主动定义一个long型整数，即使它没有超过int的最大限度，同时long型整数可以参与计算。这里我们需要注意的是，定义long型整数时，在数字后面可以加“l”（小写的L）或“L”都可以，但是小写的L（“l”）更像数字1，为了便于阅读，我们这里强烈建议在定义时用大写的L。

五、Python中的进制

      0x开头的16进制：

>>> 0xF15

      0开头的8进制：

>>> 0108

      这里重点注意的是，当我们在赋值时，一定要注意，比如 v  = 010，不要误以为010就等于十进制的10或误认为010是一种错误的写法。数字前面多加一个0意思就完全变了。

六、变量的定义及赋值

>>> x = 2>>> x * 510

上面的例子中，定义了一个变量x，并将int类型2,赋值给了x，切记不是x等于2的意思。

>>> input("The meaning of life:")The meaning of life:4242

input函数获取用户的输入值。当用户输入42后，回车，立即输出了输入值42。在上面的例子中我们只能输入数字类型，如果输入了非数字类型，就会报错：

>>> input("The meaning of life:")The meaning of life:testTraceback (most recent call last):  File "<stdin>", line 1, in <module>  File "<string>", line 1, in <module>NameError: name 'test' is not defined

后面在讲到input 与 raw_input 的区别的时候就会明白为什么。

>>> x = input("x=")x=34>>> y = input("y=")y=56>>> print x * y1904

除此之外，还可以根据输入的数字进行各种运算。

七、常用函数的初步了解

• pow函数，幂运算

>>> 2**38>>> pow(2,3)8>>>

实现幂运算可以用上面的两种形式，“**”符号已经在上面的例子中了解了基本用法，这里我们只重点关注pow函数。

pow函数分为Python自带函数和math模块函数，下面做一个对比： 

 Python自带 math模块 代码示例 使用方式 直接pow使用 需要导入math模块，使用import math语句 Python自带： 

>>> pow(2,3)8

math模块： 

>>> import math>>> math.pow(2,3)8.0

语法 

pow(x, y [,z])

z 可选项，表示结果对z取模，等价于：

x**y % z

math.pow(x,y) Python自带： 

>>> pow(2,3)8>>> 2**38>>> pow(2,3,6)2>>> 2**3%62

math模块，发现math.pow并不支持取模的方式： 

>>> math.pow(2,3,6)Traceback (most recent call last):  File "<stdin>", line 1, in <module>TypeError: pow expected 2 arguments, got 3>>>>>> math.pow(2,3)8.0

结果不同点 当参数为整数时，返回的就是整数类型。当参数为float时，也能正常float类型返回。 管参数是否整数，返回的都是float类型。 Python自带： 

>>> pow(2,3)8>>> pow(2.1,2)4.41

math模块，发现结果为8.0： 

>>> math.pow(2,3)8.0>>> math.pow(2.1,2)4.41

• abs函数，取绝对值 
  

      语法abs(x)，即取x的绝对值。 

>>> abs(-100)100>>> abs(100)100>>> abs(-23.343)23.343>>> abs(2000L)2000L>>> abs(-2000L)2000L

• round函数，四舍五入 
  

语法：round(x [,n])。

x-要四舍五入的数值；

n-保留小数位数，如果不写默认保留整数，小数点后1位并且是0

>>> round(2.645,2)2.65>>> round(2.645)3.0

注意：round函数存在的一些问题： 
一、round函数与Python的版本有关系，如下： 

Python2 

>>> round(0.5)1.0

Python3 

>>> round(0.5)0

上述的差异，我们看一下官方文档的说明:

Python2：

保留值将保留到离上一位更近的一端（四舍六入），如果距离两端一样远，则保留到离0远的一边。所以round(0.5)会近似到1，而round(-0.5)会近似到-1；

Python3：

如果距离两边一样远，会保留到偶数的一边。比如round(0.5)和round(-0.5)都会保留到0，而round(1.5)会保留到2；

二、round得到的结果未必是想要的，如下：

>>> round(2.675,2)2.67>>> round(2.375,2)2.38

区别在于2.675舍掉了后面的5，而2.375是5入一位。怎么解释这种现象？

round(2.675, 2) 的结果，不论我们从python2还是3来看，结果都应该是2.68的，结果它偏偏是2.67，为什么？这跟浮点数的精度有关。我们知道在机器中浮点数不一定能精确表达，因为换算成一串1和0后可能是无限位数的，机器已经做出了截断处理。那么在机器中保存的2.675这个数字就比实际数字要小那么一点点。这一点点就导致了它离2.67要更近一点点，所以保留两位小数时就近似到了2.67。

• floor(x)函数，返回小于或等于x的最大整数（向下取整） 
  

语法floor(x)

该函数无法直接使用，需要import math。

>>> import math>>> math.floor(-47.34)-48.0>>> math.floor(100.99)100.0>>> math.floor(1000L)1000.0>>> math.floor(math.pi)3.0

返回小于或等于x的最大整数，即向下取整。

• ceil(x)函数，返回大于或等于x的最小整数（向上取整） 
  

语法ceil(x)

ceil与floor是相对的，所有同样需要import math。

>>> import math>>> math.ceil(-47.34)-47.0>>> math.ceil(100.01)101.0>>> math.ceil(1000L)1000.0>>> math.ceil(math.pi)4.0

返回大于或等于x的最小整数（向上取整）。

在上述例子中floor和ceil返回的都是float类型，如果想得到int类型，可以使用int类型进行类型转换： 

>>> int (math.floor(32.9))32>>> int (math.ceil(32.9))33

同理，对于类型转换，除了int(object)外，还有float(object)、long(object)

int() 和 long() 在参数为字符串时，字符串内必须是int或long的样式，如果出现小数点就会报错，如下：

>>> int(12.9)12>>> int("12")12>>> int("12.9")Traceback (most recent call last):  File "<stdin>", line 1, in <module>ValueError: invalid literal for int() with base 10: '12.9'>>>>>> int("a")Traceback (most recent call last):  File "<stdin>", line 1, in <module>ValueError: invalid literal for int() with base 10: 'a'>>> long(100)100L>>> long(100.99)100L>>> long("100")100L>>> long("100.99")Traceback (most recent call last):  File "<stdin>", line 1, in <module>ValueError: invalid literal for long() with base 10: '100.99'>>> long(100L)100L>>> long("a")Traceback (most recent call last):  File "<stdin>", line 1, in <module>ValueError: invalid literal for long() with base 10: 'a'>>> long("100L")100L>>> float(12)12.0>>> float(12.45)12.45>>> float("12")12.0>>> float("12.45")12.45>>> float("a")Traceback (most recent call last):  File "<stdin>", line 1, in <module>ValueError: could not convert string to float: a

• sqrt函数，返回平方根 
  

语法：sqrt(x)

该函数同样不能直接使用，需要import math模块。

>>> import math>>> math.sqrt(9)3.0>>> math.sqrt(0)0.0>>> math.sqrt(-9)Traceback (most recent call last):  File "<stdin>", line 1, in <module>ValueError: math domain error

可以看到x的值必须大于等于0。且返回的是float类型。

当x小于0的时候，程序报错了，但负数是用平方根的，负数的平方根是虚数。这是如果要计算负数的平方根需要导入cmath（complex math）模块。

>>> import cmath>>> cmath.sqrt(-9)3j

面的3j就是虚数。另外Python本身自带了对复数计算的支持，但并没有单独的虚数类型，他们被看做实数部分为0的复数。 

>>> 3j*39j

八、导入模块

在以上的例子中，我们已经用到了import这种语句，称为“导入模块”。

语句：import 模块名

比如：

>>> import math>>> math.pow(2,3)8.0

另一种导入的语句格式为“from 模块名 import 函数”。这种导入的模块的方式好处是在使用函数时不用“模块名.函数名”了，直接使用函数即可： 

>>> from math import sqrt>>> sqrt(9)3.0

这种使用的缺点是，如果两个不同的模块中有相同的函数名，则后面导入的函数会把前面导入的函数覆盖掉。

比如，math模块的sqrt和cmath的sqrt函数：

>>> from math import sqrt>>> from cmath import sqrt>>> sqrt(9)(3+0j)>>>>>> from cmath import sqrt>>> from math import sqrt>>> sqrt(9)3.0

我们也可以把函数赋给一个变量 ：

>>> import math>>> foo = math.sqrt>>> foo(9)3.0

九、Python脚本的运行

在以上的例子中，都是使用交互式方式写的代码片。我们也可以写到脚本文件中，脚本文件.py后缀名结尾； 

命令提示符运行脚本：

Window系统

C:\Users\yangliehui>python hello.py

或Linux系统 

$python hello.py

当然了，前提是要配置环境变量，如果不想配置环境变量，也可以在Python安装目录下执行脚本。

十、Python中的注释

“#”号注释符

>>> #这一行是注释... print "hello"hello

#号后面的内容Python会忽略。

十一、字符串初步了解

字符串的详细内容，会在后面的内容中占用一整章节来学习，现在只做一些初步的了解。

>>> "hello World"'hello World'>>> 'hello World''hello World'

在上面的字符串中，发现单引号和双引号是一样的，在交互式方式下，都打印出了'hello World'。

>>> "Let's go!""Let's go!">>> '"Hello World!" she said''"Hello World!" she said'

单引号与双引号的两种使用方式，可以满足字符串中出现单引号和双引号的情形。如果不用这种方式，还可以使用反斜线转义。 

>>> 'Let\'s go!'"Let's go!">>> "\"Hello World!\" she said"'"Hello World!" she said'

反斜线转义。

>>> "Let's say" '"Hello World!"''Let\'s say"Hello World!"'

一个字符串接一个字符串的方式可以拼接成一个新的字符串，单引号字符串和双引号字符串可以混合使用，如上例。

这种方式只在同时写两个字符串的情况下才有效，下面的方式并不能拼接：

>>> x = "Hello">>> y = "World!">>> x y  File "<stdin>", line 1    x y      ^SyntaxError: invalid syntax

但是一般的拼接字符串还是用以下方式：

“+”号拼接

>>> "Let's say"  +  '"Hello World!"''Let\'s say"Hello World!"'>>>>>> x = "Hello">>> y = "World!">>> x + y'HelloWorld!'

注意：字符串表示：str和repr 
先来看一段程序： 

>>> "Hello World!"'Hello World!'>>>>>> print "Hello World!"Hello World!

两种方式下打印的Hello World！并不一样，上面的带引号，下面的不带引号。

带引号的输出值会保持其在Python代码中的状态；

而不带引号的输出是希望用户所看到的状态；

为了印证上面的区别，看下面代码： 

>>> "Hello World!"'Hello World!'>>> 10000L10000L>>>>>> print "Hello World!"Hello World!>>> print 10000L10000

我们看到'Hello World!' 和 10000L是其在代码中的状态值； 

而Hello World！和 10000是显示给用户看到的； 

面这两种不同的输出字符串的方式，我们可以使用函数来实现： 

>>> print repr("Hello World!")'Hello World!'>>> print repr(10000L)10000L>>>>>> print str("Hello World!")Hello World!>>> print str(10000L)10000

我们可以看到： 

repr函数输出会保持其在Python代码中的状态；

str函数输出是希望用户所看到的状态；

repr(x)函数等价于`x`（x为数字的情况下成立） 

>>> print "Hello" + 32Traceback (most recent call last):  File "<stdin>", line 1, in <module>TypeError: cannot concatenate 'str' and 'int' objects>>>>>>>>> print "Hello" + `32`Hello32>>>>>>>>> print "Hello" + repr(32)Hello32>>> print "Hello" + str(32)Hello32

字符串直接拼接数字是不行的。可以使用下面的三种方式，注意反引号“`”，可以把32转换为字符串方式，而且等价repr函数。 

总结：str，repr、反引号是将Python值转换为字符串的三种方式： 

str让字符串更易于阅读； 

repr（和反引号）把字符串转换为合法的Python的表达式； 

长字符串的了解：

>>> print '''This is a very long... string '''This is a very longstring>>>>>> print """This is a very long... string """This is a very longstring

这种字符串支持多行。而且由于三个引号的特殊性，字符串中间出现的单引号或双引号就不需要再转义了。 
除了三个引号可以使字符串换行以外，还可以使用反斜线，如下： 

>>> print "Hello \... World!"Hello World!>>> 1+2\... +36>>> print \... "Hello World!"Hello World!

原始字符串： 
看一段代码： 

>>> print "C:\name"

面的代码我们预期输出C:\name,可实际输出的是这样的： 

>>> print "C:\name"C:ame

出现上面问题的原因是\n转义符换行的意思，因此在“:”后换行了，并且输出了ame。避免出现类似情况的方法是对“\”进行转移。 

>>> print "C:\\name"C:\name

看起来没有问题，但是当路径很长的时候就显得不那么方便了，因此还有方式就是使用原始字符串。 

>>> print r"C:\name"C:\name

r开头的原始字符串如上所示。它会原样输出字符串的内容。

上面的代码原始字符串中“\”反斜线不能出现在最后，如：

>>> print r"C:\name\"  File "<stdin>", line 1    print r"C:\name\"                    ^SyntaxError: EOL while scanning string literal

这是显而易见的，后面加的反斜线把后面的引号转义了。如果非要在后面加上反斜线可以把反斜线转义了。 

>>> #结尾会出现两个反斜线... print r"C:\name\\"C:\name\\>>> #如果只想结尾出现一个反斜线... print r"C:\name" + "\\"C:\name\

十二、input 与 raw_input 的区别 

先看一下例子： 

>>> name = input("What's your name ?\r\n")What's your name ?yangliehuiTraceback (most recent call last):  File "<stdin>", line 1, in <module>  File "<string>", line 1, in <module>NameError: name 'yangliehui' is not defined

使用input函数时当输入名字后程序报错了。原因是input会认为用户输入的是合法的Python表达式，和下面的这行代码没什么区别

>>> yangliehuiTraceback (most recent call last):  File "<stdin>", line 1, in <module>NameError: name 'yangliehui' is not defined

因此下面的写法就不会报错： 

>>> name = input("What's your name ?\r\n")What's your name ?"yangliehui">>> print nameyangliehui

因为这种写法等价于：

>>> print "yangliehui"yangliehui

再来看一下raw_input: 

>>> name = raw_input("What's your name?\r\n")What's your name?yangliehui>>> name'yangliehui'>>>>>> age = raw_input("How old are you?\r\n")How old are you?30>>> age'30'>>>

我们看到使用raw_input时不用在加引号，因为raw_input会把所有的输入当做原始数据（raw data）然后放入字符串中。我们可以看到输出值都是字符串。 

十三、获得帮助

要善用help()函数获得帮助。