数据类型
整数：1，101，-8080，0，等等。浮点数：3.14，1.234，1.23e9，2.3e8，等等。字符串：以‘ ’或者“ ”括起来的任意文本。
# 字符串切片
s = 'ABCDEFG';
s[:3] # ==> 'ABC'
S[:-3] # ==> 'EFG'
S[::2] # ==> 'ACEG'
# 字符串可以通过 % 进行格式化，用指定的参数替代 %s。
d = { 'Adam': 95, 'Lisa': 85, 'Bart': 59 }
tds = ['<tr><td>%s</td><td>%s</td></tr>' % (name, score) for name, score in d.iteritems()]
# 字符串的join()方法可以把一个 list 拼接成一个字符串。
print '<table border="1"><tr><th>Name</th><th>Score</th><tr>'.join(tds).'</table>'
# <table border="1"><tr><th>Name</th><th>Score</th><tr><tr><td>Lisa</td><td>85</td></tr><tr><td>Adam</td><td>95</td></tr><tr><td>Bart</td><td>59</td></tr></table>
布尔值：True，False(注意大小写)。空值：None。list：list是一种有序的集合，可以随时添加和删除其中的元素。
# 创建list
L = ['Michael', 'Bob', 'Tracy']
# 空的list
empty_list = []
print L[0] # ==> 'Michael'。使用索引时，千万注意不要越界。
print L[-1] # ==> 'Tracy'。倒序访问
# 向list中插入元素
L.append('Paul') # ['Michael', 'Bob', 'Tracy', 'Paul']
L.insert(0, 'Paul') # [ 'Paul', 'Michael', 'Bob', 'Tracy']
L.insert(1, 'Paul') # ['Michael', 'Paul', 'Bob', 'Tracy']
# 从list中删除元素
L.pop() # ==> 'Tracy',若不传参数pop()方法总是删掉list的最后一个元素，并且它还返回这个元素。
L.pop(1) # ==> 'Bob'
# 从list中替换元素
L[2] = 'Paul' # ['Michael', 'Bob', 'Paul']
# list 切片
L[0:3] # ['Michael', 'Bob', 'Tracy'],如果第一个索引是0，还可以省略。
L[1:3] # ['Bob', 'Tracy']
L[:] # ['Michael', 'Bob', 'Tracy'] 只用一个 : ，表示从头到尾。 L[:]实际上复制出了一个新list。
L[::2] # ['Michael', 'Tracy'] 第三个参数表示每N个取一个，上面的 L[::2] 会每两个元素取出一个来，也就是隔一个取一个。
L[-2:] # ['Bob', 'Tracy'] 倒序切片
# 用方法生成list
range(1, 11) # ==> [1, 2, 3, 4, 5, 6, 7, 8, 9, 10]
# 列表生成式
[x * x for x in range(1, 11)] # ==> [1, 4, 9, 16, 25, 36, 49, 64, 81, 100]
# 列表生成式中的条件过滤
[x * x for x in range(1, 11) if x % 2 == 0] # ==> [4, 16, 36, 64, 100]
# 多层表达式
[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)
tuple：tuple是另一种有序的列表，中文翻译为“ 元组 ”。tuple 和 list 非常类似，但是，tuple一旦创建完毕，就不能修改了。
# 创建tuple
t = ('Adam', 'Lisa', 'Bart')
# () 既可以表示tuple，又可以作为括号表示运算时的优先级，如下：
t = (1)
print t # ==> 1
t = (1,)
print t # ==> (1,)
dict:花括号 {} 表示这是一个dict，然后按照 key: value, 写出来即可。最后一个 key: value 的逗号可以省略。
dict查找速度快，无论dict有10个元素还是10万个元素，查找速度都一样。而list的查找速度随着元素增加而逐渐下降。但是dict占用的内存比较大，还会浪费很多内容。list正好相反，占用内存小，但是查找速度慢。由于dict是按 key 查找，所以在一个dict中，key不能重复。
dict的的key-value序对是没有顺序的！这和list不一样。作为key 的元素必须不可变，Python的基本类型如字符串、整数、浮点数都是不可变的，都可以作为 key。但是list是可变的，就不能作为 key。
# 创建dict
d = {
'Adam': 95,
'Lisa': 85,
'Bart': 59
}
# 计算集合的大小
len(d) # ==> 3
# 集合访问
print d['Adam'] # ==> 95。key不存在会报错用如下方法检测key是否存在
if 'Paul' in d:
print d['Paul']
d.get('Bart') # ==> 59
# 更新dict
d['Paul'] = 72 # {'Lisa': 85, 'Paul': 72, 'Adam': 95, 'Bart': 59}，如果 key 已经存在，则赋值会用新的 value 替换掉原来的 value
set：set 持有一系列元素，这一点和 list 很像，但是set的元素没有重复，而且是无序的，这点和 dict 的 key很像。set存储的元素和dict的key类似，必须是不变对象。
# 创建set，调用 set() 并传入一个 list
s = set(['A', 'B', 'C'])
print s # ==> set(['A', 'C', 'B'])
# set不包含重复元素
s = set(['A', 'B', 'C', 'C'])
print s # ==> set(['A', 'C', 'B'])
# set访问
#由于set存储的是无序集合，所以我们没法通过索引来访问，访问 set中的某个元素实际上就是判断一个元素是否在set中。可以用 in 操作符判断
'B' in s # ==> True
# 更新set
s = set([1, 2, 3])
s.add(4) # set([1, 2, 3, 4])
s.remove(4) # set([1, 2, 3])
s.add(3) # set([1, 2, 3])
语句
print语句可以向屏幕上输出指定的内容。
# print语句也可以跟上多个字符串，用逗号“,”隔开，就可以连成一串输出
print 'The quick brown fox', 'jumps over', 'the lazy dog'
print 300+200+100
print "\"To be, or not to be\": that is the question.Whether it\'s nobler in the mind to suffer."
# 我们可以在字符串前面加个前缀 r ，表示这是一个 raw 字符串，里面的字符就不需要转义了。
print r'''"To be, or not to be": that is the question.Whether it's nobler in the mind to suffer.'''
for循环(迭代)：
# 遍历(迭代)list
L = ['Adam', 'Lisa', 'Bart']
for name in L:
print name # Adam Lisa Bart
# 遍历(迭代)dict
d = { 'Adam': 95, 'Lisa': 85, 'Bart': 59 }
for key in d:
print key，':',d[key] # ==> Adam: 95 Lisa: 85 Bart: 59
# 迭代 dict 的value。
# values() 方法，这个方法把dict转换成一个包含所有value的list。
for v in d.values():
print v # 85 95 59
# itervalues() 方法不会转换，它会在迭代过程中依次从 dict 中取出 value，所以 itervalues() 方法比 values() 方法节省了生成 list 所需的内存。但是迭代的效果是一样的
for v in d.itervalues():
print v # 85 95 59
# 迭代 dict 的key和value。
for key, value in d.items():
print key, ':', value
# dict 对象的 items() 方法返回的值：
print d.items() # ==> [('Lisa', 85), ('Adam', 95), ('Bart', 59)]
# 遍历(迭代)set
s = set(['Adam', 'Lisa', 'Bart'])
for name in s:
print name # ==> Lisa Adam Bart
# Python中，迭代永远是取出元素本身，而非元素的索引,想在for循环中拿到索引，可以使用enumerate() 函数。
L = ['Adam', 'Lisa', 'Bart', 'Paul']
for index, name in enumerate(L):
print index, '-', name
# numerate() 函数把上述的list变成了类似[(0, 'Adam'), (1, 'Lisa'), (2, 'Bart'), (3, 'Paul')]的一个list,因此，迭代的每一个元素实际上是一个tuple。
for t in enumerate(L):
index = t[0]
name = t[1]
print index, '-', name
# 如果我们知道每个tuple元素都包含两个元素，for循环又可以进一步简写为上述的形式。
四则运算
Python支持对整数和浮点数直接进行四则混合运算，运算规则和数学上的四则运算规则完全一致。
1 + 2 + 3 # ==> 6
4 * 5 - 6 # ==> 14
7.5 / 8 + 2.1 # ==> 3.0375
# 小括号提升优先级
(1 + 2) * 3 # ==> 9
(2.2 + 3.3) / (1.5 * (9 - 0.3)) # ==> 0.42145593869731807
# Python的整数运算结果仍然是整数，浮点数运算结果仍然是浮点数
1 + 2 # ==> 整数 3
1.0 + 2.0 # ==> 浮点数 3.0
# 但是整数和浮点数混合运算的结果就变成浮点数了
1 + 2.0 # ==> 浮点数 3.0
11.0 / 4 # ==> 2.75
# 求余的运算
11 % 4 # ==> 3
逻辑运算
# 与运算：只有两个布尔值都为 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内置函数的调用：
# 要调用一个函数，需要知道函数的名称和参数,如果传入的参数数量不对，会报TypeError的错误。
abs(-20) # ==> 20
cmp(1, 2) # ==> -1
cmp(3, 2) # ==> 1
定义函数和调用：在Python中，定义一个函数要使用 def 语句，依次写出函数名、括号、括号中的参数和冒号：
def my_abs(x):
if x >= 0:
return x
else:
return -x
# 定义默认参数
def greet(name='world'):
print 'Hello, ' + name + '.'
greet() # ==> Hello, world
greet('Bart') # ==> Hello, Bart
# 定义可变参数
def fn(*args):
print args
fn() # ==> ()
fn('a') # ==> ('a',)
fn('a','b') # ==> ('a','b')