Python基础

简介

Python是开源的
Python由很多解释器：CPython（官方），IPython（增强交互模式），PyPy（动态编译，性能高），Jython（编译成Java字节码），IronPython（编译.net字节码）
print 'hello world!'//打印hello world！，字符串需要使用单引号或者双引号括起来
exit()退出Python
使用文本编辑器
记事本会自作聪明地在文件开始的地方加上几个特殊字符（UTF-8 BOM），结果会导致程序运行出现莫名其妙的错误。

输入输出函数

Python 2.7的print()函数和Python 3的print()函数使用方法不一样
Python2.7：
print 'Hello world!'

Python 3：
print('Hello world!')

输入函数：raw_input()

name = raw_input()
print name

还可以有参数，会在调用时输出：
raw_input('please input:')
运行后会先输出：'please input:'

Python中#为注释，Python解释器会自动忽略#后的内容，Pythony以缩进（Tab或者空格（一般规定四个空格））为区分代码块的标志，当语句以':'结尾时，下方缩进的代码被视为一个代码块

数据类型

• 整型 i = 9
• 浮点型 f = 8.4
• 字符串 str = 'Hello world!'
• 布尔型 True False
• 空值 None

布尔型数值可以使用与（and）或（or）非（not）运算

空值不能理解为0，None是一个特殊的值

a = 'ABC'
b = a
a = 'XYZ'
print b

结果为：ABC
在执行a='XYZ'时，又重新分配了新空间，让a指向新空间，b的不变

常量：Python中没有常量，但是通常用大写字母表示常量，如：PI = 3.1414

字符编码：
很久很久以前，世界上只有一种编码ASCII，它只有一个字节，能编码2^{8种字符，后来，随着世界的发展，很多国家的字符都想进行编码，2}8=256种编码就不够用了。于是，Unicode编码横空出世，Unicode编码通常使用两个字节进行编码，可以有2^16=65536种编码方式，为了兼容ASCII编码，普通的ASCII前补上八位0就是相对应的Unicode编码。但是又有一个问题出现了，如果字符串中英文字符占得特别多，就会浪费很多空间，在存储和网络传输中都不方便。所以UTF-8编码应运而生，UTF-8编码和其他两种编码方式最大的不同是采用了可变长的字符编码，每个字符大约占1-6字节，普通英文字符占1个字节，汉字通常占3个字节，这三种编码方式的相互转换如下所示：

字符	ASCII	Unicode	UTF-8
a	01000001	00000000 01000001	01000001
中	-	01001110 00101101	11100100 10111000 10101101

常见的ASCII编码：
0 48
A 65
Z 90
a 97
z 122

在计算机系统中，程序读取文件到内存时，统一由UTF-8转换成Unicode编码，当需要保存到硬盘或者需要经过网络传输时会再次转换成UTF-8

Python诞生的时间比Unicode标准发布的时间早，所以Python起初不支持Unicode。Python提供两个函数(ord()和chr())可以在字符和对应的十进制ASCII编码之间转换：
ord('A')#把'A'转换成十进制ASCII码
chr(65)#把65转换成对应的ASCII字符

后来Pyhon添加了对Unicode的支持，以Unicode表示的字符用u'...'表示，如：

>>> print u'中文'
中文
>>> u'中'
u'\u4e2d'

把u'xxx'转换成UTF-8编码用encode('utf-8')方法：u'ABC'.encode(‘utf-8')
把UTF-8转换成Unicode编码用decode('utf-8')方法：'abc'.decode('utf-8')

len()函数可以返回字符串的长度：

>>> len(u'ABC')
3
>>> len('ABC')
3
>>> len(u'中文')
2
>>> len('\xe4\xb8\xad\xe6\x96\x87')
6

要想让Python程序正常的显示中文，首先Python程序源文件的编码方式要是UTF-8，然后还要在程序中加上声明（# --*-- coding:utf-8 --*--）让Python以UTF-8的编码方式读取文件

格式化输出##

>>> 'Hello, %s' % 'world'
'Hello, world'
>>> 'Hi, %s, you have $%d.' % ('Michael', 1000000)
'Hi, Michael, you have $1000000.'

和C语言一样，Python使用'%'作为格式化输出的标志，%运算符就是用来格式化字符串的。在字符串内部，%s表示用字符串替换，%d表示用整数替换，有几个%?占位符，后面就跟几个变量或者值，顺序要对应好。如果只有一个%?，括号可以省略。

格式化整数和浮点数还可以指定是否补0和整数与小数的位数：

>>> '%2d-%02d' % (3, 1)
' 3-01'
>>> '%.2f' % 3.1415926
'3.14'

如果你不太确定应该用什么，%s永远起作用，它会把任何数据类型转换为字符串：

>>> 'Age: %s. Gender: %s' % (25, True)
'Age: 25. Gender: True'

对于Unicode字符串，用法完全一样，但最好确保替换的字符串也是Unicode字符串：

>>> u'Hi, %s' % u'Michael'
u'Hi, Michael'

有些时候，字符串里面的%是一个普通字符怎么办？这个时候就需要转义，用%%来表示一个%：

>>> 'growth rate: %d %%' % 7
'growth rate: 7 %'

list和tuple

list:有序集合，可以删除添加元素
使用方法classmates = ['Micheal','Bob','Tracy']
len()函数：查看元素个数：
len(classmates)#结果为3
list元素索引从0开始：
classmates[0]的值是'Micheal'
classmates[1]的值是'Bob'
classmates[2]的值是'Tracy'
classmates[3]报错，因为没有这个元素，越界了
最后一个元素的索引是len(classmates)-1
还可以使用负数作索引，表示倒数第几个元素，如
classmates[-1]的值是'Tracy'
classmates[-2]的值是'Bob'
classmates[-3]的值是'Micheal'
classmates[-4]报错，越界了
list是一个可变长的有序表，可以使用append()方法把元素添加到末尾，append()方法有一个参数：要插入的元素
classmates.append('Adam')
classmates的值是['Micheal','Bob','Tracy','Adam']
也可以使用insert()方法插入到指定位置，insert()方法有两个参数：第一个是插入位置（插入此位置，其他元素后移），第二个是插入的元素
classmates.insert(1,'Jack')#把'Jack'元素插入到索引为1的位置上
classmates的值是['Micheal','Jack','Bob','Tracy','Adam']

删除末尾元素：pop()方法
classmates.pop()#删除最后一个元素
classmates的值是['Micheal','Jack','Bob','Tracy']
删除制定元素：pop()，传入一个参数，要删除的元素的索引
classmates.pop(1)#删除索引为1的元素
classmates的值是['Micheal','Bob','Tracy']

list里的元素类型可以是不同的，如
L = ['Apple',123,True]
list里的元素也可以是一个list，如

>>> s = ['python', 'java', ['asp', 'php'], 'scheme']
>>> len(s)
4

也可以这么写：

>>> p = ['asp', 'php']
>>> s = ['python', 'java', p, 'scheme']

元素的个数还是4，不管list中的list里有几个元素，都看成是一个
元素'php'可以通过s[2][1]或者p[1]拿到
如果元素里什么内容都没有，那么他是一个空的list，长度为0

>>> L = []
>>> len(L)
0

tuple

tuple和list非常类似，不同的是tuple一旦初始化后就不能修改了，如
classmates = ('Michael', 'Bob', 'Tracy')
现在，classmates这个tuple不能变了，它也没有append()，insert()这样的方法。其他获取元素的方法和list是一样的，你可以正常地使用classmates[0]，classmates[-1]，但不能赋值成另外的元素。
不可变的tuple有什么意义？因为tuple不可变，所以代码更安全。如果可能，能用tuple代替list就尽量用tuple。

如果要定义一个只有1个元素的tuple，如果你这么定义：
t = (1)
t1

定义的不是tuple，是1
这个数！这是因为括号()既可以表示tuple，又可以表示数学公式中的小括号，这就产生了歧义，因此，Python规定，这种情况下，按小括号进行计算，计算结果自然是1。
所以，只有1个元素的tuple定义时必须加一个逗号,，来消除歧义：
t = (1,)
t(1,)

Python在显示只有1个元素的tuple时，也会加一个逗号,，以免你误解成数学计算意义上的括号。

创建一个“可变”的tuple

>>> t = ('a', 'b', ['A', 'B'])
>>> t[2][0] = 'X'
>>> t[2][1] = 'Y'
>>> t
('a', 'b', ['X', 'Y'])

表面上看，tuple的元素确实变了，但其实变的不是tuple的元素，而是list的元素。tuple一开始指向的list并没有改成别的list，所以，tuple所谓的“不变”是说，tuple的每个素，指向永远不变。即指向'a'，就不能改成指向'b'，指向一个list，就不能改成指向其他对象，但指向的这个list本身是可变的！

条件判断和循环

两种形式：

if ... :
    ...
else :
    ...

if ... :
    ...
elif ... :
    ...
......
else :
    ...

if的判断条件还可以简写

if x:
    print "True"

只要x是非零数值、非空字符串、非空list等，就判断为True，否则为False。

循环

python的循环有两种，一种是for...in...循环，另一种是while循环

names = ['Michael', 'Bob', 'Tracy']
for name in names: 
    print name

这段代码会把names里的元素都打印出来
python有一个生成序列的函数range()，传入一个参数，生成从0到这个参数的序列（包括0，不包括这个参数），如：
range(101)#生成从0到100的list

>>> a = range(5)
>>> a
[0,1,2,3,4]

raw_input()函数，不管输入的是什么值，返回值都是一个字符串，如果要想使输入的字符串和int类型的值比较，就要进行类型转换，i = (int)raw_input()

dict和set

dict（字典）其他语言也称为map，使用键值对存储key-value
定义dict：

>>> d = {'Micheal':90,'Bob':70,'Tracy':80}
>>> d['Micheal']
90

定义字典使用{}，访问字典里的元素使用[]而不是{}
字典初始化后，还可以通过key放入元素：
d['Adam'] = 79#将新元素放入d这个字典中
字典中key和value的值是一一对应的，key是唯一的，当向字典中新插入元素的key已经在字典中的时候，会覆盖原来的元素，相当于修改其中的元素，如：

>>> d['Micheal'] = 87
>>> d['Micheal']
87

如果访问key不存在的元素会报错
可以使用in判断key是否存在：
'Tomas' is in d#结果为False
还可以使用dict提供的get()方法判断key是否存在，不存在会返回None（返回None时，python不会输出任何结果），或者传入第二个参数，如果不存在会返回第二个参数指定的值：

d.get('Tomas')#返回结果为None，不会有任何输出
d.get('Tomas',-1)
-1#指定了返回值

要删除dict中的元素可以使用pop()方法：
d.pop('Bob')#把key为'Bob'的元素删除
dict内部存放的顺序和key放入的顺序是没有关系的，dict根据key来计算value的存储位置，这个通过key计算位置的算法称为哈希算法（Hash），所以dict的key必须是不可变对象，如果每次计算相同的key得出的结果不同，那dict内部就完全混乱了。**

在Python中，字符串、整数等都是不可变的，因此，可以放心地作为key。而list是可变的，就不能作为key

和list比较，dict有以下几个特点：

• 查找和插入的速度极快，不会随着key的增加而增加；
• 需要占用大量的内存，内存浪费多。

而list相反：

• 查找和插入的时间随着元素的增加而增加；
• 占用空间小，浪费内存很少。

所以，dict是用空间来换取时间的一种方法。

set（集合）

set和dict类似，但是set只存储key，不存储value，因为只存储key，所以set中的元素不重复
要创建一个set，需要传入一个list，list中的每个元素都会作为set中的key，重复的元素会被过滤掉，可以使用add()方法向set中添加元素，重复向set中添加相同的元素也会被过滤掉

>>> s = set([1,1,2,2,3,4,5])
>>> s
set([1,2,3,4,5])
>>> s.add(5)
>>> s
set([1,2,3,4,5])

可以通过remove()方法移除set中的元素：

>>> s.remove(4)
>>> s
set([1,2,3,5])

set可以看成是数学中无序的无重复元素的集合，同样可以进行交集，并集的操作：

>>> s1 = ([1,2,3])
>>> s2 = ([2,3,4])
>>> s1 & s2#交集
set([2,3])
>>> s1 | s2#并集
set([1,2,3,4])

set和dict的唯一区别仅在于没有存储对应的value，但是，set的原理和dict一样，所以，同样不可以放入可变对象，因为无法判断两个可变对象是否相等，也就无法保证set内部“不会有重复元素”。

不可变对象

对于可变对象，比如list，对list进行操作，list内部的内容是会变化的，比如：

>>> a = ['c', 'b', 'a']
>>> a.sort()
>>> a
['a', 'b', 'c']

可变对象调用改变自身的方法，会改变自身

而对于不可变对象，比如str，对str进行操作呢：

>>> a = 'abc'
>>> a.replace('a', 'A')
'Abc'
>>> a
'abc'

虽然字符串有个replace()方法，也确实变出了'Abc'，但变量a最后仍是'abc'
我们先把代码改成下面这样：

>>> a = 'abc'
>>> b = a.replace('a', 'A')
>>> b
'Abc'
>>> a
'abc'

当我们调用a.replace('a', 'A')时，实际上调用方法replace是作用在字符串对象'abc'上的，而这个方法虽然名字叫replace，但却没有改变字符串'abc'的内容。相反，replace方法创建了一个新字符串'Abc'并返回，如果我们用变量b指向该新字符串，就容易理解了，变量a仍指向原有的字符串'abc'，但变量b却指向新字符串'Abc'了

对于不可变对象，调用改变自身的方法，不会改变自身，会新创建一个对象返回

end