一、版本说明
本学习教程所有代码都是基于Python2.7版本。
二、Python的第一个语句
根据“国际惯例”，学习一门语言，总要先写一个“Hello World !”，那么来吧：
>>> print "Hello World !"
Hello World !
看起来很简单，print语句打印出了“Hello World !”字符串，与大部分语言相比，我们发现语句结尾并没有加分号（“;”），Python中一行就是一个可执行语句，当然如果我们尝试加上分号也没有关系，并不会看到任何报错，但是这里还是建议不要加上分号。
三、数字运算
除了上面简单的打印语句外，我们还可以直接进行数学运算操作，然后直接打印出运算结果，比如：
>>> 1+2
3
>>> 4*5
20
>>> 2 * math.pi * 20
125.66370614359172
>>> 1/2
0
math.pi 是π（3.1415926...）。具体导入math的一些用法，后面会涉及到。这里只需要知道，如果要使用math，必须要先写上导入语句：import math。
最后一个在计算1/2时，为什么会是0呢？这里因为整数除以整数时Python默认把小数点后面的数截掉了，嗯，就是截掉了，没有四舍五入。那如何才能得到我们预期的0.5呢？这里有两种方式：1）转换为用带小数点的实数进行运算；2）设置Python除法的执行方式；
1）转换为用带小数点的实数进行运算：
>>> 1.0/2.0
0.5
>>> 1/2.0
0.5
>>> 1.0/2
0.5
>>> 1./2
0.5
>>> 1/2.
0.5
>>> 1./2.
0.5以上都是正确的写法，小数点后的0可以不写，但建议还是规范写法便于阅读。
2）设置Python除法的执行方式：
>>> from __future__ import division
>>> 1/2
0.5或 -Qnew 的方式启动Python：
C:\Users\yangliehui>python -Qnew
Python 2.7.13 (v2.7.13:a06454b1afa1, Dec 17 2016, 20:53:40) [MSC v.1500 64 bit (AMD64)] on win32
Type "help", "copyright", "credits" or "license" for more information.
>>> 1/2
0.5
在以上两种方式下除号“/”不能实现截取小数点的整除了，但Python提供了一个可以在上述两种方式下实现截取小数并整除的方式——双斜杠：
>>> 1/2
0.5
>>> 1//2
0
>>> 1.0//2.0
0.0 可以看到，使用//，即使是浮点数1.0//2.0也实现了小数点的截取整除；
除了上面的几个运算之外，还有取余运算和幂运算，我们这里简单提及一下：
取余运算——x%y
>>> 10 % 3
1
幂运算——x ** y
>>> 2 ** 3
8
>>> -2 ** 2
-4
>>> (-2) ** 2
4
四、长整数
当我们在写一个整数的时候，Python默认会认为是int类型整数，比如：
>>> 1000
1000但是，当数字特别大，大到超过int类型的最大长度时，Python就会自动帮我们转为long型。int与long型的具体区别在后面的课程中还会深入的涉及到，这里我们只需要知道，整数类型有int和long，当整数超过int规定的最大长度时就必须要用long类型表示。那么这个int的最大值是多大呢？我们可以用下面的代码查一下：
>>> import sys
>>> print sys.maxint
21474836472147483647就是int的最大值（正好是：2 ^ 31 - 1 = 2147483647），超过这个最大值，Python就会自动帮我们转换为long类型：
>>> 2147483647
2147483647
>>> 2147483648
2147483648L
>>> 2147483647 + 1
2147483648L我们看到当整数大于2147483647后，Python输出的整数后面加上了“L”。这里，我们说整数被被动的转换为了long型了，那么我们可不可以主动直接定义一个long型整数呢？看下面的例子：
>>> 100l
100L
>>> 100L
100L
>>> 100L * 3
300L从上面的例子看，我们可以主动定义一个long型整数，即使它没有超过int的最大限度，同时long型整数可以参与计算。这里我们需要注意的是，定义long型整数时，在数字后面可以加“l”（小写的L）或“L”都可以，但是小写的L（“l”）更像数字1，为了便于阅读，我们这里强烈建议在定义时用大写的L。
五、Python中的进制
0x开头的16进制：
>>> 0xF
15
0开头的8进制：
>>> 010
8
六、变量的定义及赋值
>>> x = 2
>>> x * 5
10上面的例子中，定义了一个变量x，并将int类型2,赋值给了x，切记不是x等于2的意思。
>>> input("The meaning of life:")
The meaning of life:42
42input函数获取用户的输入值。当用户输入42后，回车，立即输出了输入值42。在上面的例子中我们只能输入数字类型，如果输入了非数字类型，就会报错：
>>> input("The meaning of life:")
The meaning of life:test
Traceback (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 * y
1904除此之外，还可以根据输入的数字进行各种运算。
七、常用函数的初步了解
• pow函数，幂运算
>>> 2**3
8
>>> pow(2,3)
8
>>>
实现幂运算可以用上面的两种形式，“**”符号已经在上面的例子中了解了基本用法，这里我们只重点关注pow函数。
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**3
8
>>> pow(2,3,6)
2
>>> 2**3%6
2
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.0Python3
>>> 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*3
9j
八、导入模块
”。
语句：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!'
>>> 10000L
10000L
>>>
>>> print "Hello World!"
Hello World!
>>> print 10000L
10000我们看到'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" + 32
Traceback (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 long
string
>>>
>>> print """This is a very long
... string """
This is a very long
string这种字符串支持多行。而且由于三个引号的特殊性，字符串中间出现的单引号或双引号就不需要再转义了。
除了三个引号可以使字符串换行以外，还可以使用反斜线，如下：
>>> print "Hello \
... World!"
Hello World!
>>> 1+2\
... +3
6
>>> 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 ?
yangliehui
Traceback (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表达式，和下面的这行代码没什么区别
>>> yangliehui
Traceback (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 name
yangliehui因为这种写法等价于：
>>> 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()函数获得帮助。
本文章为转载内容，我们尊重原作者对文章享有的著作权。如有内容错误或侵权问题，欢迎原作者联系我们进行内容更正或删除文章。
