1.1 交互式解释器
默认centos6上安装了python2.6.6
直接敲命令 python就可以直接进入交互式的python解释器，在这里，我们可以敲一些python的命令。比如进行加减法
>>> 10+1
11
也可以做浮点运算
>>> 1.0/2
0.5
这里有个技巧，我们输入的数字带小数点，那么计算的结果也带，如果不带，就认为是整形
>>> 1/2
0
如下是，其他的一些常用运算
>>> 1*3
3
>>> 9%2
1
>>> 2**3
8
>>> (-5)**2
25
其中两个*表示是次方，也就是幂运算。
1.2 变量
这个东西，咱们并不陌生，就是赋值。
>>> a=1
>>> a
1
>>> a*3
3
关于变量名，有个小规定：可以包括字母、数字和下划线。不能以数字开头。其实这个和shell变量名的限定是一样的。
>>> a_1=2
>>> a_1
2
也可以大写
>>> A_1=1
>>> A_1
1
以上所有例子当中，都是在变量赋值以后，我们直接输入变量名就出来变量的值，其实我们也可以这样输出：
>>> b=3
>>> print b
3
1.3 用户输入
在shell中，我们经常会写和用户交互的脚本，先提醒用户输入一个数字或者字符串，然后返回一些结果。python当中也是有这个功能的：
>>> raw_input("Please input a number: ")
Please input a number: 12
12
我们输入什么，它返回什么。这样貌似不是我想要的效果，再来看：
>>> a=raw_input("a: ")
a: 1
>>> b=raw_input("b: ")
b: 2
>>> print a+b
3
这样看，容易理解多了，第一次我们给a赋值，第二次我们又给b赋值。
1.4 判断语句if
>>> if a<b: print 1
...
1
因为a=1,b=2,所以判断条件是真，所以直接打印1了。要注意的是，在条件语句后面有个冒号，表示判断结束，我们输入这条命令回车后，发现并没有输出结果，需要我们再按一次回车才行。
1.5 函数
函数有内置的，也有自定义的，比如下面的函数是内置的：
>>> max(1,2)
2
>>> pow(2,5)
32
max就是取最大值，而pow是幂运算
我们再来自定义一个函数
>>> def sum(x,y):
... print (x+y)
...
>>> sum(1,2)
3
说明：def是函数的前缀，说明我们要定义一个函数了，sum是函数名，小括号里面是参数，参数可以有多个。然后回车后，需要敲4次空格，也就是所谓的缩进，这个一定要注意，有的人喜欢用tab，但是有的编辑器不识别会出错，所以建议大家还是4个空格。然后再一次回车，告诉它，函数结束。然后我们再引用这个函数，就直接出结果啦。
1.6 模块
模块是python里一个非常重要的元素，很多情况下，我们需要借助模块来实现一些功能，比如在python脚本里我们可以执行linux系统命令，那么就要借助os模块。下面看例子：
>>> import os
>>> os.system("hostname")
aminglinux.com
0
说明：os是个模块，而os后面的.system是一个函数，函数里面就是我们敲的linux shell命令，回车后它输出内容。而后又输出一个0，表示这个命令成功了，这是返回值，就跟linux的echo $？一样
下面我们来自己写个简单的模块：
先退出交互式的python解释器。使用ctrl + D
编辑我们的自定义模块，其实就是写一个python脚本，名字为aming.py,内容如下：
#!/usr/bin/python
a=1
b=2
def sum(x,y):
return x+y
然后再次进入python交互式解释器
>>> import aming
>>> aming.a
1
>>> aming.b
2
>>> aming.sum(10,1)
11
说明：在aming.py这个脚本里，我们定义了a和b两个变量，也定义了一个函数sum，当我们把aming这个模块插入后，我们就可以在当前的python环境中引用aming.a和aming.b这两个变量，同意也可以引用aming.sum这个函数。
1.7 python脚本
刚刚的演示只是在python的交互式解释器中，真正工作中，我们不是这样做的，下面我来真正写一个python脚本。
vim 1.py 内容如下：
#!/usr/bin/python
## this is a python script.
print "Hello!"
print ‘world.‘
运行它：
python 1.py
Hello!
world.
说明：第一行跟shell脚本中第一行一样的作用，告诉python的路径，第二行以#开头，代表它是一行解释说明的行，然后紧接着就是两个print打印，一个用的双引号，一个用的单引号，他们其实作用是一样的，但在双引号或单引号里面我不能写变量名，这个和shell是有所区别的,我们再来看下面的脚本。
vim 2.py 内容如下：
#!/usr/bin/python
c=‘abc‘
print c
print "c"
print ‘c‘
python 2.py
abc
c
c
或者给2.py一个可执行权限： chmod a+x 2.py
然后这样执行： ./2.py
再来一个交互的脚本：
vim 3.py
#!/usr/bin/python
name=raw_input("Please input your name: ")
print name
执行
python 3.py
Please input your name: aming
aming
再来升级一下这个脚本：
vim 3.py
#!/usr/bin/python
name=raw_input("Please input your name: ")
print ‘hello, ‘ + name + "!"
python 3.py
Please input your name: aming
hello, aming!
说明：字符串需要用单引号或者双引号引起来，其中+的作用是连接。关于单引号，有时候我们会遇到这样的情况，就是在字符串中还有单引号，比如：
a=‘My name‘s aming‘
这样肯定是不对的，因为有三个单引号，引起了混淆，所以要么使用双引号：
a="My name‘s aming"
要么这样：
a=‘My name\‘s aming‘
2. 列表和元组
列表：a=[‘a‘, 1, ‘c‘, 5]
元组：b=(1,2,3,4,5)
这两者很像，最大的区别在于列表可变，可以修改，但元组不可以。我们把列表和元组统称为序列，另外一种数据结构（字典）在后面内容中介绍。
>>> a=[1,2,3]
>>> b=(4,5)
>>> a+b
>>> b[0]=‘a‘
Traceback (most recent call last):
File "<stdin>", line 1, in <module>
TypeError: ‘tuple‘ object does not support item assignment
>>> a[0]=‘a‘
>>> a
[‘a‘, 2, 3]
说明：a是一个列表，我们可以更改a的第一个元素，而b是一个元组，不可以重新对其元素赋值。
2.1 索引
序列中所有元素都是有编号的，从0开始计数，如a[0],b[0]，最后一个元素编号是-1。
>>> a=[‘a‘, 1, ‘c‘, 5]
>>> b=(1,2,3,4,5)
>>> a[0]
‘a‘
>>> b[-1]
5
>>> a[-2]
‘c‘
这个带有位置编号的表示叫做索引，索引可以引用到函数中：
>>> n=raw_input("Please input a number: ")[-1]
Please input a number: 192
>>> n
‘2‘
序列是支持+和*的：
>>> a=[1,2,3]
>>> b=[‘a‘,‘b‘,‘c‘]
>>> a+b
[1, 2, 3, ‘a‘, ‘b‘, ‘c‘]
>>> 2*a+3*b
[1, 2, 3, 1, 2, 3, ‘a‘, ‘b‘, ‘c‘, ‘a‘, ‘b‘, ‘c‘, ‘a‘, ‘b‘, ‘c‘]
>>> a=(1,2,3)
>>> b=(4,5)
>>> a+b
(1, 2, 3, 4, 5)
>>> a*2
(1, 2, 3, 1, 2, 3)
2.2 分片
分片其实就是一个范围，格式类似于1:3
>>> n=[10,9,8,7,6]
>>> n[1:3]
[9, 8]
和我们想的不一样，1:3并不是1,2,3三个元素，而只有1和2，也就说冒号右边的数字是不包含在分片内的。下面再看几个例子：
>>> n[3:1]
[]
>>> n[-3:-1]
[8, 7]
>>> n[0:3]
[10, 9, 8]
>>> n[:3]
[10, 9, 8]
>>> n[3:]
[7, 6]
>>> n[3:4]
[7]
>>> n[3:5]
[7, 6]
>>> n[3:6]
[7, 6]
主要有几个点：
1.冒号左侧数字小于右侧；
2.两侧可以有一个为空，表示从序列头开始或者到序列尾；
3.右侧数值可以大于元素个数，效果等同于右侧数字为空；
关于分片，我们还可以定义元素的步长：
>>> n=[1,2,3,4,5,6,7,8,9,10]
>>> n[0:10:1]
[1, 2, 3, 4, 5, 6, 7, 8, 9, 10]
>>> n[0:10:2]
[1, 3, 5, 7, 9]
>>> n[0:10:3]
[1, 4, 7, 10]
这里用了两个冒号，最后面的数字就是步长，另外步长可以定义为负数，这样我们之前说的观点，冒号左侧数字小于右侧就不对了。如下：
>>> n[10:0:-2]
[10, 8, 6, 4, 2]
>>> n[10:0:-1]
[10, 9, 8, 7, 6, 5, 4, 3, 2]
>>> n[10::-1]
[10, 9, 8, 7, 6, 5, 4, 3, 2, 1]
2.3 in运算符
>>> a=‘xyz‘
>>> ‘x‘ in a
True
>>> ‘b‘ in a
False
in检查一个字符或者字符串是否在序列中。
>>> a=[1,2,‘a‘]
>>> a
[1, 2, ‘a‘]
>>> ‘a‘ in a
True
>>> 3 in a
False
2.4 三个内建函数len,max,min
>>> n=[12,100,9]
>>> len(n)
3
>>> max(n)
100
>>> min(n)
9
2.5 list 函数，可以让我们快速创建一个列表
>>> list(‘aminglinux‘)
[‘a‘, ‘m‘, ‘i‘, ‘n‘, ‘g‘, ‘l‘, ‘i‘, ‘n‘, ‘u‘, ‘x‘]
>>> list (‘123456‘)
[‘1‘, ‘2‘, ‘3‘, ‘4‘, ‘5‘, ‘6‘]
2.6 删除列表的元素
>>> a=list(‘aminglinux‘)
>>> del a[2]
>>> a
[‘a‘, ‘m‘, ‘n‘, ‘g‘, ‘l‘, ‘i‘, ‘n‘, ‘u‘, ‘x‘]
2.7 分片赋值
>>> a=list(‘aminglinux‘)
>>> a[5:]=list (‘python‘)
>>> a
[‘a‘, ‘m‘, ‘i‘, ‘n‘, ‘g‘, ‘p‘, ‘y‘, ‘t‘, ‘h‘, ‘o‘, ‘n‘]
另外还有这样的用法，类似于插入
>>> b=list (‘19‘)
>>> b
[‘1‘, ‘9‘]
>>> b[1:1]
[]
>>> b[1:1]=list (‘234‘)
>>> b
[‘1‘, ‘2‘, ‘3‘, ‘4‘, ‘9‘]
既然可以插入，我还可以反过来用，即删除
>>> b[1:4]=[]
>>> b
[‘1‘, ‘9‘]
2.8 列表内建的一些方法（函数）
下面我们讲的所有方法都是列表内置的。
1） append追加新的元素
>>> a=[1,2,‘a‘]
>>> a.append(4)
>>> a
[1, 2, ‘a‘, 4]
2） count 统计某个元素在整个列表中出现的次数
>>> b=list (‘aminglinux‘)
>>> b.count(‘i‘)
2
3）extend 比append更加好用，它可以直接增加一个列表
>>> a=[1,2,3]
>>> b=[‘a‘,‘b‘]
>>> a.extend(b)
>>> a
[1, 2, 3, ‘a‘, ‘b‘]
4）index找出指定元素所在位置
>>> month=[‘jan‘, ‘feb‘, ‘mar‘, ‘apr‘, ‘may‘]
>>> month.index(‘mar‘)
2
如果列表中有多个‘mar‘那它只找出第一个
>>> month[-1]=‘mar‘
>>> month
[‘jan‘, ‘feb‘, ‘mar‘, ‘apr‘, ‘mar‘]
>>> month.index(‘mar‘)
2
5）insert将对象插入列表中
>>> a
[1, 2, 3, ‘a‘, ‘b‘]
>>> a.insert(2,6)
>>> a
[1, 2, 6, 3, ‘a‘, ‘b‘]
小括号里面有两个数字，第一个表示位置，第二个表示要插入的元素，可以是数字也可以是字母，甚至是字符串。
>>> a.insert(2,‘aming‘)
>>> a
[1, 2, ‘aming‘, 6, 3, ‘a‘, ‘b‘]
6）pop移除列表中的元素，默认是最后一个
>>> a
[1, 2, ‘aming‘, 6, 3, ‘a‘, ‘b‘]
>>> a.pop()
‘b‘
>>> a
[1, 2, ‘aming‘, 6, 3, ‘a‘]
当然我也可以指定具体的位置
>>> a.pop(3)
6
>>> a
[1, 2, ‘aming‘, 3, ‘a‘]
7）remove移除指定的元素，如果列表中有多个类似的元素，那么会移除第一个
>>> a.insert(3,2)
>>> a
[1, 2, ‘aming‘, 2, 3, ‘a‘]
>>> a.remove(‘a‘)
>>> a
[1, 2, ‘aming‘, 2, 3]
>>> a.remove(2)
>>> a
[1, ‘aming‘, 2, 3]
8）reverse反向
>>> a
[1, ‘aming‘, 2, 3]
>>> a.reverse()
>>> a
[3, 2, ‘aming‘, 1]
9）sort将列表排序
>>> a
[3, 2, ‘aming‘, 1]
>>> a.sort()
>>> a
[1, 2, 3, ‘aming‘]
小常识：有时候我们操作一个列表，因为列表是可变的，所以一旦使用了某个方法，那么列表就发生了改变，我们如果想再次使用原始的列表值，就有点麻烦了。所以，我们可以把列表在使用某个方法之前就先把该列表赋值给另外一个列表：
>>> a
[1, 2, 3, ‘aming‘]
>>> b=a
>>> b
[1, 2, 3, ‘aming‘]
>>> type (b)
<type ‘list‘>
>>> a.append(1)
>>> a
[1, 2, 3, ‘aming‘, 1]
>>> b
[1, 2, 3, ‘aming‘, 1]
>>> b=a[:]
>>> a.append(1)
>>> a
[1, 2, 3, ‘aming‘, 1, 1]
>>> b
[1, 2, 3, ‘aming‘, 1]
上面的例子，告诉我们，简单b=a这样是不行的，这样相当于b只是指向了a，当a改变时，b也跟着变了。而真正赋值的做法是b=a[:]。
2.9 最后再来介绍一个关于元组的函数tuple
类似于list，tuple只是把一个字符串直接给变成元组：
>>> a=tuple(‘aminglinux‘)
>>> a
(‘a‘, ‘m‘, ‘i‘, ‘n‘, ‘g‘, ‘l‘, ‘i‘, ‘n‘, ‘u‘, ‘x‘)
元组和列表很像，但元组最大的特点是不可修改，后续章节我们会逐步使用到元组。