Python 基础知识
1.空值
空值是Python中特殊的一个值，用None表示。None不能理解为0，因为0是有意义的也不能理解为 ‘ ’ 。
2.输出 print
print 语句可以连接多个字符串，用逗号“,”隔开，就可以连接成一个字符串输出。print会依次打印每个字符串，遇到逗号“,”会输出一个空格，因此，输出的字符串是这样拼起来的：
3.Python中raw字符串与多行字符串
如果一个字符串包含很多需要转义的字符，对每一个字符都进行转义会很麻烦。为了避免这种情况，我们可以在字符串前面加个前缀 r ，表示这是一个 raw 字符串，里面的字符就不需要转义了。例如：
r'\(~_~)/ \(~_~)/'
如果要表示多行字符串，可以用'''...'''表示：
'''Line 1
Line 2
Line 3'''
4.Python中整数和浮点数
和数学运算不同的地方是，Python的整数运算结果仍然是整数，浮点数运算结果仍然是浮点数：
1 + 2 # ==> 整数 3
1.0 + 2.0 # ==> 浮点数 3.0
但是整数和浮点数混合运算的结果就变成浮点数了：
1 + 2.0 # ==> 浮点数 3.0
那整数的除法运算遇到除不尽的时候，结果难道不是浮点数吗？我们来试一下：
11 / 4 # ==> 2
令很多初学者惊讶的是，Python的整数除法，即使除不尽，结果仍然是整数，余数直接被扔掉。不过，Python提供了一个求余的运算 % 可以计算余数：
11 % 4 # ==> 3
如果我们要计算 11 / 4 的精确结果，按照“整数和浮点数混合运算的结果是浮点数”的法则，把两个数中的一个变成浮点数再运算就没问题了：
11.0 / 4 # ==> 2.75
Python 中的布尔类型
与运算：只有两个布尔值都为 True 时，计算结果才为 True。
True and True # ==> True True and False # ==> False False and True # ==> False False and False # ==> False
或运算：只要有一个布尔值为 True，计算结果就是 True。
True or True # ==> True True or False # ==> True False or True # ==> True False or False # ==> False
非运算：把True变为False，或者把False变为True：
not True # ==> False not False # ==> True
Python把0、空字符串''和None看成 False，其他数值和非空字符串都看成 True
>>> a = 'python'
>>> print 'hello,', a or 'world'
hello, python
>>> b = ''
>>> print 'hello,', b or 'world'
hello, world
5.Python创建list
Python内置的一种数据类型是列表：list。list是一种有序的集合，可以随时添加和删除其中的元素。 由于python是动态语言完全可以包含多种数据类型
>>> classmates = ['Michael', 'Bob', 'Tracy'] >>> classmates # 打印classmates变量的内容 ['Michael', 'Bob', 'Tracy']
>>> L = ['Michael', 100 ,true]
需要特别注意的是，索引从 0 开始，也就是说，第一个元素的索引是0，第二个元素的索引是1，以此类推。
因此，要打印第一名同学的名字，用 L[0]:
>>> print L[0] Adam
Bart同学是最后一名，俗称倒数第一，所以，我们可以用 -1 这个索引来表示最后一个元素：
>>> print L[-1] Bart
Bart同学表示躺枪。
Python之添加新元素
>>> L = ['Adam', 'Lisa', 'Bart']
>>> L.append('Paul')
>>>print L
['Adam', 'Lisa', 'Bart', 'Paul']
append()总是把新的元素添加到 list 的尾部。
方法是用list的 insert()方法，它接受两个参数，第一个参数是索引号，第二个参数是待添加的新元素：
>>> L = ['Adam', 'Lisa', 'Bart'] >>> L.insert(0, 'Paul') >>> print L ['Paul', 'Adam', 'Lisa', 'Bart']
Python从list删除元素 如果Paul同学排在最后一个，我们可以用list的pop()方法删除：
>>> L = ['Adam', 'Lisa', 'Bart', 'Paul']
>>> L.pop()
'Paul'
>>>print L
['Adam', 'Lisa', 'Bart']
List中删除指定元素 pop(2) 删掉第三个元素
>>> L = ['Adam', 'Lisa', 'Paul', 'Bart']
>>> L.pop(2)
'Paul' >>> print L ['Adam', 'Lisa', 'Bart']
Python中替换元素 对list中的某一个索引赋值，就可以直接用新的元素替换掉原来的元素，list包含的元素个数保持不变。
L = ['Adam', 'Lisa', 'Bart']
>>> L[2] = 'Paul'
>>> print L
L = ['Admin', 'Lisa', 'Paul']
由于Bart还可以用 -1 做索引，因此，下面的代码也可以完成同样的替换工作：
>>> L[-1] = 'Paul'
Python之创建tuple
tuple是另一种有序的列表，中文翻译为“ 元组 ”。tuple 和 list 非常类似，但是，tuple一旦创建完毕，就不能修改了。 创建tuple和创建list唯一不同之处是用( )替代了[ ]。
同样是表示班里同学的名称，用tuple表示如下：
>>> t = ('Admin', 'Lisa', 'Bart')
因为用()定义单元素的tuple有歧义，所以 Python 规定，单元素 tuple 要多加一个逗号“,”，这样就避免了歧义：
>>> t = (1,) >>> print t (1,)
当tuple中包含一个list时，由于List可以改变导致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'])
6.Python之什么是dict
Python的 dict 就是专门干这件事的。用 dict 表示“名字”-“成绩”的查找表如下：
d = {
'Adam': 95,
'Lisa': 85,
'Bart': 59
}
我们把名字称为key，对应的成绩称为value，dict就是通过 key 来查找 value。
注意: 通过 key 访问 dict 的value，只要 key 存在，dict就返回对应的value。如果key不存在，会直接报错：KeyError。
要避免 KeyError 发生，有两个办法：
一是先判断一下 key 是否存在，用 in 操作符：
if 'Paul' in d:
print d['Paul']
如果 'Paul' 不存在，if语句判断为False，自然不会执行 print d['Paul'] ，从而避免了错误。
二是使用dict本身提供的一个 get 方法，在Key不存在的时候，返回None： （推荐使用第二种方法）
>>> print d.get('Bart')
59
>>> print d.get('Paul')
None
Python循环遍历字典元素
d = {
'Adma' : 95,
'Lisa' : 85,
'Bart' : 59
}
for key, value in d.items():
print key, ':', value
Python更新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}
Python中什么是set
dict的作用是建立一组 key 和一组 value 的映射关系，dict的key是不能重复的。
有的时候，我们只想要 dict 的 key，不关心 key 对应的 value，目的就是保证这个集合的元素不会重复，这时，set就派上用场了。
set 持有一系列元素，这一点和 list 很像，但是set的元素没有重复，而且是无序的，这点和 dict 的 key很像。
创建 set 的方式是调用 set() 并传入一个 list，list的元素将作为set的元素：
>>> s = set(['A', 'B', 'C'])
L = ['Adam', 'Lisa', 'Bart', 'Paul']
s = set(L)
Python之 访问set
由于set存储的是无序集合，所以我们没法通过索引来访问，但是可以通过in操作符判断
>>> s = set(['Adam', 'Lisa', 'Bart', 'Paul'])
我们可以用 in 操作符判断：
Bart是该班的同学吗？
>>> 'Bart' in s True
Bill是该班的同学吗？
>>> 'Bill' in s False
bart是该班的同学吗？
>>> 'bart' in s False
Python之 遍历set
由于 set 也是一个集合，所以，遍历 set 和遍历 list 类似，都可以通过 for 循环实现。
直接使用 for 循环可以遍历 set 的元素：
直接使用 for 循环可以遍历 set 的元素：
>>> s = set(['Adam', 'Lisa', 'Bart'])
>>> for name in s:
... print name
...
Lisa
Adam
Bart
Python之 更新set 注：用add()可以直接添加，而remove()前需要判断。
由于set存储的是一组不重复的无序元素，因此，更新set主要做两件事：
一是把新的元素添加到set中，二是把已有元素从set中删除。
添加元素时，用set的add()方法： 如果添加的元素已经存在于set中，add()不会报错，但是不会加进去了：
>>> s = set([1, 2, 3]) >>> s.add(4) >>> print s set([1, 2, 3, 4])
删除set中的元素时，用set的remove()方法： 如果删除的元素不存在set中，remove()会报错：
>>> s = set([1, 2, 3, 4]) >>> s.remove(4) >>> print s set([1, 2, 3])
Python之调用函数
int()函数可以把其他数据类型转换为整数： str()函数把其他类型转换成 str：
可以在交互式命令行通过 help(abs) 查看abs函数的帮助信息。
调用 abs 函数：
>>> abs(100) 100 >>> abs(-20) 20 >>> abs(12.34) 12.34
而比较函数 cmp(x, y) 就需要两个参数，如果 x<y，返回 -1，如果 x==y，返回 0，如果 x>y，返回 1：
>>> cmp(1, 2) -1 >>> cmp(2, 1) 1 >>> cmp(3, 3) 0
Python之编写函数
如果没有return语句，函数执行完毕后也会返回结果，只是结果为 None。 return None可以简写为return。
在Python中，定义一个函数要使用 def 语句，依次写出函数名、括号、括号中的参数和冒号:，然后，在缩进块中编写函数体，函数的返回值用 return 语句返回。
我们以自定义一个求绝对值的 my_abs 函数为例：
def my_abs(x):
if x >= 0:
return x
else:
return -x
Python之定义默认参数
定义函数的时候，还可以有默认参数。
例如Python自带的 int() 函数，其实就有两个参数，我们既可以传一个参数，又可以传两个参数：
int()函数的第二个参数是转换进制，如果不传，默认是十进制 (base=10)，如果传了，就用传入的参数。
>>> int('123')
123
>>> int('123', 8)
83
Python之定义可变参数
如果想让一个函数能接受任意个参数，我们就可以定义一个可变参数：
def fn(*args):
print args
>>> fn()
()
>>> fn('a')
('a',)
>>> fn('a', 'b')
('a', 'b')
>>> fn('a', 'b', 'c')
('a', 'b', 'c')
对list进行切片
取一个list的部分元素是非常常见的操作。比如，一个list如下：
>>> L = ['Adam', 'Lisa', 'Bart', 'Paul']
取前3个元素，用一行代码就可以完成切片：
>>> L[0::3]
L[0:3]表示，从索引0开始取，直到索引3为止，但不包括索引3。即索引0，1，2，正好是3个元素。如果第一个数字是0还可以省略。 L[:3]
也可以从索引1开始，取出2个元素出来：
>>>L[1:3]
只用一个 : ，表示从头到尾：
>>>L[:] 相当于复制一份list
切片操作还可以指定第三个参数： 第三个参数表示每N个取一个，上面的 L[::2] 会每两个元素取出一个来，也就是隔一个取一个
>>> L[::2] ['Adam', 'Bart']
倒序切片
对于list，既然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。倒序切片包含起始索引，不包含结束索引。
对字符串切片
取除首字母外的字符串用[1:]
s = 'abcdefg'
s[1:]>>'bcdefg'
字符串 'xxx'和 Unicode字符串 u'xxx'也可以看成是一种list，每个元素就是一个字符。因此，字符串也可以用切片操作，只是操作结果仍是字符串：
>>> 'ABCDEFG'[:3] 'ABC' >>> 'ABCDEFG'[-3:] 'EFG' >>> 'ABCDEFG'[::2] 'ACEG'
注意：字符串有个方法 upper() 可以把字符变成大写字母：
>>> 'abc'.upper() 'ABC'
什么是迭代
在Python中，如果给定一个list或tuple，我们可以通过for循环来遍历这个list或tuple，这种遍历我们成为迭代（Iteration）。
注意: 集合是指包含一组元素的数据结构，我们已经介绍的包括： 1. 有序集合：list，tuple，str和unicode； 2. 无序集合：set 3. 无序集合并且具有 key-value 对：dict
索引迭代
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
zip()函数可以把两个 list 变成一个 list：
>>> zip([10, 20, 30], ['A', 'B', 'C']) [(10, 'A'), (20, 'B'), (30, 'C')]
迭代dict的value
dict 对象有一个 values() 方法，或者 itervalues()这个方法把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
那这两个方法有何不同之处呢？
1. values() 方法实际上把一个 dict 转换成了包含 value 的list。
2. 但是 itervalues() 方法不会转换，它会在迭代过程中依次从 dict 中取出 value，所以 itervalues() 方法比 values() 方法节省了生成 list 所需的内存。
3. 打印 itervalues() 发现它返回一个 <dictionary-valueiterator> 对象，这说明在Python中，for 循环可作用的迭代对象远不止 list，tuple，str，unicode，dict等，任何可迭代对象都可以作用于for循环，而内部如何迭代我们通常并不用关心。
迭代dict的key和value
我们了解了如何迭代 dict 的key和value，那么，在一个 for 循环中，能否同时迭代 key和value？答案是肯定的。
items()或者iteritems() 方法把dict对象转换成了包含tuple的list，我们对这个list进行迭代，可以同时获得key和value：
iteritems() 不把dict转换成list，而是在迭代过程中不断给出 tuple，所以， iteritems() 不占用额外的内存。
>>> for key, value in d.items(): ... print key, ':', value ... Lisa : 85 Adam : 95 Bart : 59
生成列表（列表生成式）
提示：range(1, 100, 2) 可以生成list [1, 3, 5, 7, 9,...]
要生成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]怎么做？方法一是循环
但是循环太繁琐，而列表生成式则可以用一行语句代替循环生成的list：
>>> [x * x for x in range(1, 11)] [1, 4, 9, 16, 25, 36, 49, 64, 81, 100]
字符串的join()方法可以把一个 list 拼接成一个字符串。
条件过滤
列表生成式的 for 循环后面还可以加上 if 判断。例如：
>>> [x * x for x in range(1, 11) if x % 2 == 0]
[4, 16, 36, 64, 100]
有了 if 条件，只有 if 判断为 True 的时候，才把循环的当前元素添加到列表中。
1. isinstance(x, str) 可以判断变量 x 是否是字符串；
2. 字符串的 upper() 方法可以返回大写的字母。
多层表达式
for循环可以嵌套，因此，在列表生成式中，也可以用多层 for 循环来生成列表。
对于字符串 'ABC' 和 '123'，可以使用两层循环，生成全排列：
>>> [m + n for m in 'ABC' for n in '123']
['A1', 'A2', 'A3', 'B1', 'B2', 'B3', 'C1', 'C2', 'C3']
