python基础

一、数据类型

整型：计算机由于使用二进制，所以，有时候用十六进制表示整数比较方便，十六进制用0x前缀和0-9，a-f表示
浮点数：对于很大或很小的浮点数，就必须用科学计数法表示，把10用e替代，1.23x10^9就是1.23e9，或者12.3e8，0.000012可以写成1.2e-5，等等。
整数和浮点数在计算机内部存储的方式是不同的，整数运算永远是精确的（除法难道也是精确的？是的！），而浮点数运算则可能会有四舍五入的误差。
字符串：
字符串是以''或""括起来的任意文本，比如'abc'，"xyz"等等。请注意，''或""本身只是一种表示方式，不是字符串的一部分，因此，字符串'abc'只有a，b，c这3个字符。
布尔值：布尔值和布尔代数的表示完全一致，一个布尔值只有True、False两种值，要么是True，要么是False，在Python中，可以直接用True、False表示布尔值（请注意大小写），也可以通过布尔运算计算出来。
布尔值可以用and、or和not运算。
and运算是与运算，只有所有都为 True，and运算结果才是 True。
or运算是或运算，只要其中有一个为 True，or 运算结果就是 True。
not运算是非运算，它是一个单目运算符，把 True 变成 False，False 变成 True。
空值：空值是Python里一个特殊的值，用None表示。None不能理解为0，因为0是有意义的，而None是一个特殊的空值。

二、python之print语句

print语句也可以跟上多个字符串，用逗号“,”隔开，就可以连成一串输出：

>>> print 'The quick brown fox', 'jumps over', 'the lazy dog'
The quick brown fox jumps over the lazy dog

print会依次打印每个字符串，遇到逗号“,”会输出一个空格，因此，输出的字符串是这样拼起来的：

image

三、python之变量

在Python程序中，变量是用一个变量名表示，变量名必须是大小写英文、数字和下划线（_）的组合，且不能用数字开头。
在Python中，等号=是赋值语句，可以把任意数据类型赋值给变量，同一个变量可以反复赋值，而且可以是不同类型的变量。

a = 123    # a是整数
print a
a = 'imooc'   # a变为字符串
print a

这种变量本身类型不固定的语言称之为动态语言，与之对应的是静态语言。

理解变量在计算机内存中的表示也非常重要。当我们写：a = 'ABC'时，Python解释器干了两件事情：
1）在内存中创建了一个'ABC'的字符串；
2）在内存中创建了一个名为a的变量，并把它指向'ABC'。
也可以把一个变量a赋值给另一个变量b，这个操作实际上是把变量b指向变量a所指向的数据。

四、python之字符串

定义字符串

如果字符串本身包含'怎么办？比如我们要表示字符串 I'm OK ，这时，可以用" "括起来表示：

"I'm OK"

类似的，如果字符串包含"，我们就可以用' '括起来表示：

'Learn "Python" in imooc'

如果字符串既包含'又包含"，就需要对字符串的某些特殊字符进行“转义”，Python字符串用\进行转义。

'Bob said \"I\'m OK\".'

由于 ' 和 " 会引起歧义，因此，我们在它前面插入一个\表示这是一个普通字符，不代表字符串的起始。
注意：转义字符\不计入字符串的内容中。

常用的转义字符还有：
\n 表示换行
\t 表示一个制表符
\\ 表示\字符本身

raw字符串与多行字符串

如果一个字符串包含很多需要转义的字符，对每一个字符都进行转义会很麻烦。为了避免这种情况，我们可以在字符串前面加个前缀 r ，表示这是一个raw字符串，里面的字符就不需要转义了。
但是r'...'表示法不能表示多行字符串，也不能表示包含'和"的字符串。
如果要表示多行字符串，可以用'''...'''表示：

print '''Line 1
Line 2
Line 3'''

上面这个字符串的表示方法和下面的是完全一样的：

print 'Line 1\nLine 2\nLine 3'

还可以在多行字符串前面添加r，把这个多行字符串也变成一个raw字符串：

r'''Python is created by "Guido".
It is free and easy to learn.
Let's start learn Python in imooc!'''

unicode字符串

因为计算机只能处理数字，如果要处理文本，就必须先把文本转换为数字才能处理。最早的计算机在设计时采用8个比特（bit）作为一个字节（byte），所以，一个字节能表示的最大的整数就是255（二进制11111111=十进制255），0 - 255被用来表示大小写英文字母、数字和一些符号，这个编码表被称为ASCII编码，比如大写字母A的编码是65，小写字母z的编码是122。
如果要表示中文，显然一个字节是不够的，至少需要两个字节，而且还不能和ASCII编码冲突，所以，中国制定了GB2312编码，用来把中文编进去。
类似的，日文和韩文等其他语言也有这个问题。为了统一所有文字的编码，Unicode应运而生。Unicode把所有语言都统一到一套编码里，这样就不会再有乱码问题了。
Unicode通常用两个字节表示一个字符，原有的英文编码从单字节变成双字节，只需要把高字节全部填为0就可以。
因为Python的诞生比Unicode标准发布的时间还要早，所以最早的Python只支持ASCII编码，普通的字符串'ABC'在Python内部都是ASCII编码的。
Python在后来添加了对Unicode的支持，以Unicode表示的字符串用u'...'表示，比如：

>>>print u'中文'
中文

raw+多行：

ur'''Python的Unicode字符串支持"中文",
"日文",
"韩文"等多种语言'''

如果中文字符串在Python环境下遇到UnicodeDecodeError，这是因为.py文件保存的格式有问题。可以在第一行添加注释

# -*- coding: utf-8 -*-

目的是告诉Python解释器，用UTF-8编码读取源代码。
注意：当有注释的时候，字符串前就不需要加u了。

对字符串切片

字符串'xxx'和Unicode字符串u'xxx'也可以看成是一种list，每个元素就是一个字符。因此，字符串也可以用切片操作，只是操作结果仍是字符串：

>>> 'ABCDEFG'[:3]
'ABC'
>>> 'ABCDEFG'[-3:]
'EFG'
>>> 'ABCDEFG'[::2]
'ACEG'

五、python之list

Python内置的一种数据类型是列表：list。list是一种有序的集合，可以随时添加和删除其中的元素。
构造list非常简单，按照上面的代码，直接用[ ]把list的所有元素都括起来，就是一个list对象。
由于Python是动态语言，所以list中包含的元素并不要求都必须是同一种数据类型，我们完全可以在list中包含各种数据：

>>> L = ['Michael', 100, True]

倒序访问list

可以用-1这个索引来表示最后一个元素：

>>> print L[-1]
Bart

类似的，倒数第二用-2表示，倒数第三用-3表示，倒数第四用-4表示

添加新元素

第一个办法是用list的append()方法，把新同学追加到list的末尾：

>>> L = ['Adam', 'Lisa', 'Bart']
>>> L.append('Paul')
>>> print L
['Adam', 'Lisa', 'Bart', 'Paul']

添加到其他位置，用list的insert()方法，它接受两个参数，第一个参数是索引号，第二个参数是待添加的新元素：

>>> L = ['Adam', 'Lisa', 'Bart']
>>> L.insert(0, 'Paul')
>>> print L
['Paul', 'Adam', 'Lisa', 'Bart']

删除元素

如果是删除最后一个元素，可以用list的pop()方法删除：

>>> L = ['Adam', 'Lisa', 'Bart', 'Paul']
>>> L.pop()
'Paul'
>>> print L
['Adam', 'Lisa', 'Bart']

pop()方法总是删掉list的最后一个元素，并且它还返回这个元素，所以我们执行L.pop()后，会打印出'Paul'。

如果是删除其他位置的元素，则在pop()函数中写入索引下标：

>>> L = ['Adam', 'Lisa', 'Bart', 'Paul']
>>> L.pop(2)
'Bart'
>>> print L
['Adam', 'Lisa', 'Paul']

替换元素

直接利用索引下标赋值替换：

>>> L = ['Adam', 'Lisa', 'Bart']
>>> L[2] = 'Paul'
>>> print L
L = ['Adam', 'Lisa', 'Paul']

对list进行切片

取前3个元素，用一行代码就可以完成切片：

>>> L = ['Adam', 'Lisa', 'Bart', 'Paul']
>>> L[0:3]
['Adam', 'Lisa', 'Bart']

L[0:3]表示，从索引0开始取，直到索引3为止，但不包括索引3。
如果第一个索引是0，还可以省略：

>>> L[:3]
['Adam', 'Lisa', 'Bart']

只用一个:，表示从头到尾：

>>> L[:]
['Adam', 'Lisa', 'Bart', 'Paul']

L[:]实际上复制出了一个新list。
切片操作还可以指定参数：
1）第一个参数表示起始位置
2）第二个参数表示终止位置
3）第三个参数表示间隔数或第一个参数的倍数
4）这三个参数，彼此之间用:隔开
5）这些参数，可以省略

>>> L[::2]
['Adam', 'Bart']

表示每N个取一个，上面的L[::2]会每两个元素取出一个来，也就是隔一个取一个。
把list换成tuple，切片操作完全相同，只是切片的结果也变成了tuple。

倒序切片

Python支持L[-1]取倒数第一个元素，它同样支持倒数切片:

>>> L = ['Adam', 'Lisa', 'Bart', 'Paul']

>>> L[-2:]
['Bart', 'Paul']

>>> L[:-2]
['Adam', 'Lisa']

>>> L[-3:-1]
['Lisa', 'Bart']

>>> L[-4:-1:2]
['Adam', 'Bart']

倒数第一个元素的索引是-1。倒序切片包含起始索引，不包含结束索引。
可以将索引的顺序想像成一个x轴。

六、python之tuple

tuple是另一种有序的列表，中文翻译为“元组”。tuple和list非常类似，但是，tuple一旦创建完毕，就不能修改了。
创建tuple和创建list唯一不同之处是用( )替代了[ ]。
tuple没有append()方法，也没有insert()和pop()方法。

创建单元素tuple

>>> t = (1)
>>> print t
1

这里的t不是tuple，而是整数1。因为()既可以表示tuple，又可以作为括号表示运算时的优先级，结果(1)被Python解释器计算出结果 1，导致我们得到的不是tuple，而是整数 1。
正是因为用()定义单元素的tuple有歧义，所以Python规定，单元素tuple要多加一个逗号“,”，这样就避免了歧义：

>>> t = (1,)
>>> print t
(1,)

Python在打印单元素tuple时，也自动添加了一个“,”，为了更明确地告诉你这是一个tuple。
多元素tuple加不加这个额外的“,”效果是一样的：

>>> t = (1, 2, 3,)
>>> print t
(1, 2, 3)

“可变”的tuple

>>> t = ('a', 'b', ['A', 'B'])

注意到t有3个元素：'a'，'b'和一个list：['A', 'B']。list作为一个整体是tuple的第3个元素。list对象可以通过t[2]拿到：

>>> L = t[2]

然后，我们把list的两个元素改一改：

>>> L[0] = 'X'
>>> L[1] = 'Y'

再看看tuple的内容：

>>> print t
('a', 'b', ['X', 'Y'])

看看定义的时候tuple包含的3个元素：

image.png

当我们把list的元素'A'和'B'修改为'X'和'Y'后，tuple变为：

image.png

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

七、python之dict

花括号{}表示这是一个dict，然后按照key: value,写出来即可。最后一个key: value的逗号可以省略。
由于dict也是集合，len()函数可以计算任意集合的大小：

>>> len(d)
3

访问dict
可以简单地使用d[key]的形式来查找对应的value，这和list很像，不同之处是，list必须使用索引返回对应的元素，而dict使用key：

>>> print d['Adam']
95

注意: 通过key访问dict的value，只要key存在，dict就返回对应的value。如果key不存在，会直接报错：KeyError。
要避免KeyError发生，有两个办法：
1、先判断一下key是否存在，用in操作符：

if 'Paul' in d:
    print d['Paul']

2、使用dict本身提供的一个get方法，在Key不存在的时候，返回None:

>>> print d.get('Bart')
59
>>> print d.get('Paul')
None

dict的特点

dict的第一个特点是查找速度快，无论dict有10个元素还是10万个元素，查找速度都一样。而list的查找速度随着元素增加而逐渐下降。
不过dict的查找速度快不是没有代价的，dict的缺点是占用内存大，还会浪费很多内容，list正好相反，占用内存小，但是查找速度慢。
由于dict是按key查找，所以，在一个dict中，key不能重复。
dict的第二个特点就是存储的key-value序对是没有顺序的！这和list不一样。
list打印出来的顺序也不一定是我们创建时的顺序，并且不同的机器打印的顺序都可能不同，这说明dict内部是无序的，不能用dict存储有序的集合。
dict的第三个特点是作为key的元素必须不可变，Python的基本类型如字符串、整数、浮点数都是不可变的，都可以作为key。但是list是可变的，就不能作为key。
不可变这个限制仅作用于key，value是否可变无所谓：

{
    '123': [1, 2, 3],  # key 是 str，value是list
    123: '123',  # key 是 int，value 是 str
    ('a', 'b'): True  # key 是 tuple，并且tuple的每个元素都是不可变对象，value是 boolean
}

更新dict
dict是可变的，也就是说，我们可以随时往dict中添加新的key-value。比如已有dict：

d = {
    'Adam': 95,
    'Lisa': 85,
    'Bart': 59
}

要把新同学'Paul'的成绩 72 加进去，用赋值语句：

>>> d['Paul'] = 72

再看看dict的内容：

>>> print d
{'Lisa': 85, 'Paul': 72, 'Adam': 95, 'Bart': 59}

看打印的结果，可再次证明，dict是无序的。

如果key已经存在，则赋值会用新的value替换掉原来的value：

>>> d['Bart'] = 60
>>> print d
{'Lisa': 85, 'Paul': 72, 'Adam': 95, 'Bart': 60}

遍历dict
由于dict也是一个集合，所以，遍历dict和遍历list类似，都可以通过for循环实现。
直接使用for循环可以遍历dict的key：

>>> d = { 'Adam': 95, 'Lisa': 85, 'Bart': 59 }
>>> for key in d:
...     print key
... 
Lisa
Adam
Bart

由于通过key可以获取对应的value，因此，在循环体内，可以获取到value的值。

迭代dict的value

dict对象本身就是可迭代对象，用for循环直接迭代dict，可以每次拿到dict的一个key。
如果希望迭代dict对象的value，用dict对象的values()方法，这个方法把dict转换成一个包含所有value的list，这样，我们迭代的就是dict的每一个 value：

d = { 'Adam': 95, 'Lisa': 85, 'Bart': 59 }
print d.values()
# [85, 95, 59]
for v in d.values():
    print v
# 85
# 95
# 59

dict除了values()方法外，还有一个itervalues()方法，用itervalues()方法替代values()方法，迭代效果完全一样：

d = { 'Adam': 95, 'Lisa': 85, 'Bart': 59 }
print d.itervalues()
# 
for v in d.itervalues():
    print v
# 85
# 95
# 59

那这两个方法有何不同之处呢？
1）values()方法实际上把一个dict转换成了包含value的list。
2）itervalues()方法不会转换，它会在迭代过程中依次从dict中取出value，所以itervalues()方法比values()方法节省了生成list所需的内存。
3）打印itervalues()发现它返回一个对象，这说明在Python中，for 循环可作用的迭代对象远不止 list，tuple，str，unicode，dict等，任何可迭代对象都可以作用于for循环，而内部如何迭代我们通常并不用关心。

迭代dict的key和value

在一个for循环中，同时迭代key和value。
在dict对象的items()方法中，返回的值：

>>> d = { 'Adam': 95, 'Lisa': 85, 'Bart': 59 }
>>> print d.items()
[('Lisa', 85), ('Adam', 95), ('Bart', 59)]

可以看到，items()方法把dict对象转换成了包含tuple的list，我们对这个list进行迭代，可以同时获得key和value：

>>> for key, value in d.items():
...     print key, ':', value
... 
Lisa : 85
Adam : 95
Bart : 59

和values()有一个itervalues()类似，items()也有一个对应的iteritems()，iteritems()不把dict转换成list，而是在迭代过程中不断给出tuple，所以，iteritems()不占用额外的内存。

八、python之set

set持有一系列元素，这一点和list很像，但是set的元素没有重复，而且是无序的，这点和dict的key很像。
创建set的方式是调用set()并传入一个list，list的元素将作为set的元素：

>>> s = set(['A', 'B', 'C'])
>>> print s
set(['A', 'C', 'B'])

请注意，上述打印的形式类似list，但它不是list，仔细看还可以发现，打印的顺序和原始list的顺序有可能是不同的，因为set内部存储的元素是无序的。

set不能包含重复的元素，所以，当我们传入包含重复元素的list，set会自动去掉重复的元素：

>>> s = set(['A', 'B', 'C', 'C'])
>>> print s
set(['A', 'C', 'B'])
>>> len(s)
3

访问set

由于set存储的是无序集合，所以我们没法通过索引来访问。
访问set中的某个元素实际上就是判断一个元素是否在set中。
我们可以用in操作符判断：

>>> 'Bart' in s
True

大小写很重要，'Bart' 和 'bart'被认为是两个不同的元素。

set的特点

set的内部结构和dict很像，唯一区别是不存储value，因此，判断一个元素是否在set中速度很快。
set存储的元素和dict的key类似，必须是不变对象，因此，任何可变对象是不能放入set中的。
set存储的元素也是没有顺序的。

遍历set

由于set也是一个集合，所以，遍历set和遍历list类似，都可以通过for循环实现：

>>> s = set(['Adam', 'Lisa', 'Bart'])
>>> for name in s:
...     print name
... 
Lisa
Adam
Bart

注意: for循环在遍历set时，元素的顺序和list的顺序很可能是不同的，而且不同的机器上运行的结果也可能不同。

更新set

由于set存储的是一组不重复的无序元素，因此，更新set主要做两件事：
1）把新的元素添加到set中
2）把已有元素从set中删除。
添加元素时，用set的add()方法：

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

如果添加的元素已经存在于set中，add()不会报错，但是不会加进去。
删除set中的元素时，用set的remove()方法：

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

如果删除的元素不存在set中，remove()会报错。
所以用add()可以直接添加，而remove()前需要判断。

九、python之函数

在Python中，定义一个函数要使用def语句，依次写出函数名、括号、括号中的参数和冒号:，然后，在缩进块中编写函数体，函数的返回值用return语句返回。
如果没有return语句，函数执行完毕后也会返回结果，只是结果为None。
return None可以简写为return。

返回多值

import math
def move(x, y, step, angle):
    nx = x + step * math.cos(angle)
    ny = y - step * math.sin(angle)
    return nx, ny

 x, y = move(100, 100, 60, math.pi / 6)
print x, y #151.961524227 70.0
r = move(100, 100, 60, math.pi / 6)
print r #(151.96152422706632, 70.0)

用print打印返回结果，可以发现原来返回值是一个tuple！
在语法上，返回一个tuple可以省略括号，而多个变量可以同时接收一个tuple，按位置赋给对应的值，所以，Python的函数返回多值其实就是返回一个tuple。

递归函数
使用递归函数需要注意防止栈溢出。在计算机中，函数调用是通过栈（stack）这种数据结构实现的，每当进入一个函数调用，栈就会加一层栈帧，每当函数返回，栈就会减一层栈帧。由于栈的大小不是无限的，所以，递归调用的次数过多，会导致栈溢出。

默认参数
由于函数的参数按从左到右的顺序匹配，所以默认参数只能定义在必需参数的后面：

# OK:
def fn1(a, b=1, c=2):
    pass
# Error:
def fn2(a=1, b):
    pass

可变参数

如果想让一个函数能接受任意个参数，我们就可以定义一个可变参数：

def fn(*args):
    print args

可变参数的名字前面有个*号，我们可以传入0个、1个或多个参数给可变参数：

>>> fn()
()
>>> fn('a')
('a',)
>>> fn('a', 'b')
('a', 'b')
>>> fn('a', 'b', 'c')
('a', 'b', 'c')

Python解释器会把传入的一组参数组装成一个tuple传递给可变参数，因此，在函数内部，直接把变量args看成一个tuple。
定义可变参数的目的也是为了简化调用。假设我们要计算任意个数的平均值，就可以定义一个可变参数：

def average(*args):
    ...

十、迭代补充

索引迭代

Python中，迭代永远是取出元素本身，而非元素的索引。
有的时候，我们想在for循环中拿到索引，方法是使用enumerate()函数：

>>> L = ['Adam', 'Lisa', 'Bart', 'Paul']
>>> for index, name in enumerate(L):
...     print index, '-', name
... 
0 - Adam
1 - Lisa
2 - Bart
3 - Paul

使用enumerate()函数，我们可以在for循环中同时绑定索引index和元素name。
实际上，enumerate()函数把：

['Adam', 'Lisa', 'Bart', 'Paul']

变成了

[(0, 'Adam'), (1, 'Lisa'), (2, 'Bart'), (3, 'Paul')]

因此，迭代的每一个元素实际上是一个tuple。

十一、生成列表

要生成list [1, 2, 3, 4, 5, 6, 7, 8, 9, 10]，我们可以用range(1, 11)：

>>> range(1, 11)
[1, 2, 3, 4, 5, 6, 7, 8, 9, 10]

如果要生成[1x1, 2x2, 3x3, ..., 10x10]，方法一是循环：

>>> L = []
>>> for x in range(1, 11):
...    L.append(x * x)
... 
>>> L
[1, 4, 9, 16, 25, 36, 49, 64, 81, 100]

但是循环太繁琐，而列表生成式则可以用一行语句代替循环生成上面的list：

>>> [x * x for x in range(1, 11)]
[1, 4, 9, 16, 25, 36, 49, 64, 81, 100]

这种写法就是Python特有的列表生成式。利用列表生成式，可以以非常简洁的代码生成list。
写列表生成式时，把要生成的元素x * x放到前面，后面跟for循环，就可以把list创建出来，十分有用，多写几次，很快就可以熟悉这种语法。
利用列表生成式生成列表 [1x2, 3x4, 5x6, 7x8, ..., 99x100]:

print [i*(i+1) for i in range(1,100,2)]

提示：range(1, 100, 2)可以生成list[1, 3, 5, 7, 9,...]

条件过滤
列表生成式的for循环后面还可以加上if判断。例如：

>>> [x * x for x in range(1, 11)]
[1, 4, 9, 16, 25, 36, 49, 64, 81, 100]

如果我们只想要偶数的平方，不改动range()的情况下，可以加上if来筛选：

>>> [x * x for x in range(1, 11) if x % 2 == 0]
[4, 16, 36, 64, 100]

有了if条件，只有if判断为True的时候，才把循环的当前元素添加到列表中。

多层表达式
for循环可以嵌套，因此，在列表生成式中，也可以用多层for循环来生成列表。
对于字符串 'ABC' 和 '123'，可以使用两层循环，生成全排列：

>>> [m + n for m in 'ABC' for n in '123']
['A1', 'A2', 'A3', 'B1', 'B2', 'B3', 'C1', 'C2', 'C3']

翻译成循环代码就像下面这样：

L = []
for m in 'ABC':
    for n in '123':
        L.append(m + n)