一、版本说明

      本学习教程所有代码都是基于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()函数获得帮助。