1.数据类型
1）整数：Python可以处理任意大小的整数，当然包括负整数，在Python程序中，整数的表示方法和数学上的写法一模一样，例如：1，100，-8080，0，等等。
2）浮点数：浮点数也就是小数。整数和浮点数在计算机内部存储的方式是不同的，整数运算永远是精确的（除法难道也是精确的？是的！），而浮点数运算则可能会有四舍五入的误差。
3）字符串：字符串是以''或""括起来的任意文本。
4）布尔值：布尔值和布尔代数的表示完全一致，一个布尔值只有True、False两种值（请注意大小写）。
5）空值：空值是Python里一个特殊的值，用None表示。
此外，Python还提供了列表、字典等多种数据类型，还允许创建自定义数据类型。
2.print语句
print语句可以向屏幕上输出指定的文字。比如输出'hello, world'，用代码实现如下：
>>> print 'hello, world'
print语句也可以跟上多个字符串，用逗号“,”隔开，print会依次打印每个字符串，遇到逗号“,”会输出一个空格。
print也可以打印整数，或者计算结果：
>>> print 100 + 200
300 #运行结果
3.Python的注释
Python的注释以 # 开头，后面的文字直到行尾都算注释。
4.什么是变量
变量是用一个变量名表示，变量名必须是大小写英文、数字和下划线（_）的组合，且不能用数字开头。
在Python中，等号=是赋值语句，可以把任意数据类型赋值给变量，同一个变量可以反复赋值，而且可以是不同类型的变量，例如：
a = 123 # a是整数
a = 'imooc' # a变为字符串
这种变量本身类型不固定的语言称之为动态语言，与之对应的是静态语言。静态语言在定义变量时必须指定变量类型，如果赋值的时候类型不匹配，就会报错。Java是静态语言。
5.定义字符串
如果字符串本身包含'怎么办？比如我们要表示字符串 I'm OK ，这时，可以用" "括起来表示：
"I'm OK"
类似的，如果字符串包含"，我们就可以用' '括起来表示：
'Learn "Python" in imooc'
如果字符串既包含'又包含"怎么办？
这个时候，就需要对字符串的某些特殊字符进行“转义”，Python字符串用\进行转义。
要表示字符串 Bob said "I'm OK".
由于 ' 和 " 会引起歧义，因此，我们在它前面插入一个\表示这是一个普通字符，不代表字符串的起始，因此，这个字符串又可以表示为
'Bob said \"I\'m OK\".'
常用的转义字符还有：
\n 表示换行
\t 表示一个制表符
\\ 表示 \ 字符本身
6.raw字符串与多行字符串
如果一个字符串包含很多需要转义的字符，对每一个字符都进行转义会很麻烦。为了避免这种情况，我们可以在字符串前面加个前缀 r ，表示这是一个 raw 字符串，里面的字符就不需要转义了。例如：
r'\(~_~)/ \(~_~)/'
但是r'...'表示法不能表示多行字符串，也不能表示包含'和 "的字符串（为什么？）
如果要表示多行字符串，可以用'''...'''表示：
'''Line 1
Line 2
Line 3'''
上面这个字符串的表示方法和下面的是完全一样的：
'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!'''
7.Unicode字符串
Python在后来添加了对Unicode的支持，以Unicode表示的字符串用u'...'表示，比如：
print u'中文'
注意: 不加 u ，中文就不能正常显示。
如果中文字符串在Python环境下遇到 UnicodeDecodeError，这是因为.py文件保存的格式有问题。可以在第一行添加注释
# -*- coding: utf-8 -*-
目的是告诉Python解释器，用UTF-8编码读取源代码。然后用Notepad++ 另存为... 并选择UTF-8格式保存。此时不需要加u。
8.整数和浮点数
Python支持对整数和浮点数直接进行四则混合运算，运算规则和数学上的四则运算规则完全一致。
使用括号可以提升优先级，这和数学运算完全一致，注意只能使用小括号，但是括号可以嵌套很多层。
和数学运算不同的地方是，Python的整数运算结果仍然是整数，浮点数运算结果仍然是浮点数，但是整数和浮点数混合运算的结果就变成浮点数了。
为什么要区分整数运算和浮点数运算呢？这是因为整数运算的结果永远是精确的，而浮点数运算的结果不一定精确，因为计算机内存再大，也无法精确表示出无限循环小数，比如 0.1 换成二进制表示就是无限循环小数。
Python的整数除法，即使除不尽，结果仍然是整数，余数直接被扔掉。不过，Python提供了一个求余的运算 % 可以计算余数。
9.布尔类型
在Python中，布尔类型还可以与其他数据类型做 and、or和not运算，请看下面的代码：
a = True
print a and 'a=T' or 'a=F'
计算结果不是布尔类型，而是字符串 'a=T'，这是为什么呢？
因为Python把0、空字符串''和None看成 False，其他数值和非空字符串都看成 True，所以：
True and 'a=T' 计算结果是 'a=T'
继续计算 'a=T' or 'a=F' 计算结果还是 'a=T'
要解释上述结果，又涉及到 and 和 or 运算的一条重要法则：短路计算。
1. 在计算 a and b 时，如果 a 是 False，则根据与运算法则，整个结果必定为 False，因此返回 a；如果 a 是 True，则整个计算结果必定取决与 b，因此返回 b。
2. 在计算 a or b 时，如果 a 是 True，则根据或运算法则，整个计算结果必定为 True，因此返回 a；如果 a 是 False，则整个计算结果必定取决于 b，因此返回 b。
所以Python解释器在做布尔运算时，只要能提前确定计算结果，它就不会往后算了，直接返回结果。
10.创建list
Python内置的一种数据类型是列表：list。list是一种有序的集合，可以随时添加和删除其中的元素。
比如，列出班里所有同学的名字，就可以用一个list表示：
>>> ['Michael', 'Bob', 'Tracy']
构造list非常简单，按照上面的代码，直接用 [ ] 把list的所有元素都括起来，就是一个list对象。通常，我们会把list赋值给一个变量，这样，就可以通过变量来引用list：
>>> classmates = ['Michael', 'Bob', 'Tracy']
>>> classmates # 打印classmates变量的内容
['Michael', 'Bob', 'Tracy']
由于Python是动态语言，所以list中包含的元素并不要求都必须是同一种数据类型，我们完全可以在list中包含各种数据：
>>> L = ['Michael', 100, True]
11.按照索引访问list
需要特别注意的是，索引从 0 开始，也就是说，第一个元素的索引是0，第二个元素的索引是1，以此类推。
因此，要打印第一名同学的名字，用 L[0]:
>>> print L[0]
12.倒序访问list
Bart同学是最后一名，俗称倒数第一，所以，我们可以用 -1 这个索引来表示最后一个元素：
>>> print L[-1]
13.list添加新元素
现在，班里有3名同学：
>>> L = ['Adam', 'Lisa', 'Bart']
今天，班里转来一名新同学 Paul，如何把新同学添加到现有的 list 中呢？
第一个办法是用 list 的 append() 方法，把新同学追加到 list 的末尾：
>>> L = ['Adam', 'Lisa', 'Bart']
>>> L.append('Paul')
append()总是把新的元素添加到 list 的尾部。
如果 Paul 同学表示自己总是考满分，要求添加到第一的位置，怎么办？
方法是用list的 insert()方法，它接受两个参数，第一个参数是索引号，第二个参数是待添加的新元素：
>>> L = ['Adam', 'Lisa', 'Bart']
>>> L.insert(0, 'Paul')
14.list删除元素
Paul同学刚来几天又要转走了，那么我们怎么把Paul 从现有的list中删除呢？
如果Paul同学排在最后一个，我们可以用list的pop()方法删除：
>>> L = ['Adam', 'Lisa', 'Bart', 'Paul']
>>> L.pop()
'Paul'
pop()方法总是删掉list的最后一个元素，并且它还返回这个元素，所以我们执行 L.pop() 后，会打印出 'Paul'。
如果Paul同学不是排在最后一个怎么办？比如Paul同学排在第三：
>>> L = ['Adam', 'Lisa', 'Paul', 'Bart']
要把Paul踢出list，我们就必须先定位Paul的位置。由于Paul的索引是2，因此，用 pop(2)把Paul删掉。
15.list替换元素
假设现在班里仍然是3名同学：
>>> L = ['Adam', 'Lisa', 'Bart']
现在，Bart同学要转学走了，碰巧来了一个Paul同学，要更新班级成员名单，我们可以先把Bart删掉，再把Paul添加进来。
另一个办法是直接用Paul把Bart给替换掉：
>>> L[2] = 'Paul'
16.创建tuple
tuple是另一种有序的列表，中文翻译为“ 元组 ”。tuple 和 list 非常类似，但是，tuple一旦创建完毕，就不能修改了。
同样是表示班里同学的名称，用tuple表示如下：
>>> t = ('Adam', 'Lisa', 'Bart')
创建tuple和创建list唯一不同之处是用( )替代了[ ]。
现在，这个 t 就不能改变了，tuple没有 append()方法，也没有insert()和pop()方法。所以，新同学没法直接往 tuple 中添加，老同学想退出 tuple 也不行。
获取 tuple 元素的方式和 list 是一模一样的，我们可以正常使用 t[0]，t[-1]等索引方式访问元素，但是不能赋值成别的元素。
17.创建单元素tuple
tuple和list一样，可以包含 0 个、1个和任意多个元素。
包含 0 个元素的 tuple，也就是空tuple，直接用 ()表示：
>>> t = ()
>>> print t
()
创建包含1个元素的 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。
18.if语句
注意: Python代码的缩进规则。具有相同缩进的代码被视为代码块。缩进请严格按照Python的习惯写法：4个空格，不要使用Tab，更不要混合Tab和空格，否则很容易造成因为缩进引起的语法错误。
注意: if 语句后接表达式，然后用:表示代码块开始。如果你在Python交互环境下敲代码，还要特别留意缩进，并且退出缩进需要多敲一行回车。
19.if-else
if age >= 18:
print 'adult'
else:
print 'teenager'
注意: else 后面有个“:”。
20.if-elif-else
elif 意思就是 else if。
21.for循环
L = ['Adam', 'Lisa', 'Bart']
for name in L:
print name
22.while循环
N = 10
x = 0
while x < N:
print x
x = x + 1
23.break退出循环
用 for 循环或者 while 循环时，如果要在循环体内直接退出循环，可以使用 break 语句。
比如计算1至100的整数和，我们用while来实现：
sum = 0
x = 1
while True:
sum = sum + x
x = x + 1
if x > 100:
break
print sum
24.continue继续循环
在循环过程中，可以用break退出当前循环，还可以用continue跳过后续循环代码，继续下一次循环。
25.什么是dict
用 dict 表示“名字”-“成绩”的查找表如下：
d = {
'Adam': 95,
'Lisa': 85,
'Bart': 59
}
我们把名字称为key，对应的成绩称为value，dict就是通过 key 来查找 value。
花括号 {} 表示这是一个dict，然后按照 key: value, 写出来即可。最后一个 key: value 的逗号可以省略。
由于dict也是集合，len() 函数可以计算任意集合的大小。
26.访问dict
可以简单地使用 d[key] 的形式来查找对应的 value，这和 list 很像，不同之处是，list 必须使用索引返回对应的元素，而dict使用key。
注意: 通过 key 访问 dict 的value，只要 key 存在，dict就返回对应的value。如果key不存在，会直接报错：KeyError。
要避免 KeyError 发生，有两个办法：
一是先判断一下 key 是否存在，用 in 操作符：
if 'Paul' in d:
print d['Paul']
二是使用dict本身提供的一个 get 方法，在Key不存在的时候，返回None。
27.dict的特点
dict的第一个特点是查找速度快，无论dict有10个元素还是10万个元素，查找速度都一样。而list的查找速度随着元素增加而逐渐下降。
不过dict的查找速度快不是没有代价的，dict的缺点是占用内存大，还会浪费很多内容，list正好相反，占用内存小，但是查找速度慢。
由于dict是按 key 查找，所以，在一个dict中，key不能重复。
dict的第二个特点就是存储的key-value序对是没有顺序的！这和list不一样。
dict的第三个特点是作为 key 的元素必须不可变，Python的基本类型如字符串、整数、浮点数都是不可变的，都可以作为 key。但是list是可变的，就不能作为 key。
28.更新dict
dict是可变的，也就是说，我们可以随时往dict中添加新的 key-value。比如已有dict：
d = {
'Adam': 95,
'Lisa': 85,
'Bart': 59
}
要把新同学'Paul'的成绩 72 加进去，用赋值语句：
>>> d['Paul'] = 72
如果 key 已经存在，则赋值会用新的 value 替换掉原来的 value。
29.遍历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的值。
30.什么是set
set 持有一系列元素，这一点和 list 很像，但是set的元素没有重复，而且是无序的，这点和 dict 的 key很像。
创建 set 的方式是调用 set() 并传入一个 list，list的元素将作为set的元素：
>>> s = set(['A', 'B', 'C'])
31.访问set
由于set存储的是无序集合，所以我们没法通过索引来访问。
访问 set中的某个元素实际上就是判断一个元素是否在set中。
例如，存储了班里同学名字的set：
>>> s = set(['Adam', 'Lisa', 'Bart', 'Paul'])
我们可以用 in 操作符判断：
Bart是该班的同学吗？
>>> 'Bart' in s
True
32.set的特点
set的内部结构和dict很像，唯一区别是不存储value，因此，判断一个元素是否在set中速度很快。
set存储的元素和dict的key类似，必须是不变对象，因此，任何可变对象是不能放入set中的。
最后，set存储的元素也是没有顺序的。
33.更新set
由于set存储的是一组不重复的无序元素，因此，更新set主要做两件事：
一是把新的元素添加到set中，二是把已有元素从set中删除。
添加元素时，用set的add()方法。如果添加的元素已经存在于set中，add()不会报错，但是不会加进去了。
删除set中的元素时，用set的remove()方法。如果删除的元素不存在set中，remove()会报错，所以用add()可以直接添加，而remove()前需要判断。
34.调用函数
Python内置了很多有用的函数，我们可以直接调用。
要调用一个函数，需要知道函数的名称和参数，比如求绝对值的函数 abs，它接收一个参数。
也可以在交互式命令行通过 help(abs) 查看abs函数的帮助信息。
而比较函数 cmp(x, y) 就需要两个参数，如果 x<y，返回 -1，如果 x==y，返回 0，如果 x>y，返回 1。
Python内置的常用函数还包括数据类型转换函数，比如 int()函数可以把其他数据类型转换为整数。str()函数把其他类型转换成 str。
35.编写函数
在Python中，定义一个函数要使用 def 语句，依次写出函数名、括号、括号中的参数和冒号:，然后，在缩进块中编写函数体，函数的返回值用 return 语句返回。
36.函数返回多值
import math
def move(x, y, step, angle):
nx = x + step * math.cos(angle)
ny = y - step * math.sin(angle)
return nx, ny
用print打印返回结果，原来返回值是一个tuple！
但是，在语法上，返回一个tuple可以省略括号，而多个变量可以同时接收一个tuple，按位置赋给对应的值，所以，Python的函数返回多值其实就是返回一个tuple，但写起来更方便。
37.递归函数
在函数内部，可以调用其他函数。如果一个函数在内部调用自身本身，这个函数就是递归函数。
举个例子，我们来计算阶乘 n! = 1 * 2 * 3 * ... * n，用函数 fact(n)表示，可以看出：
fact(n) = n! = 1 * 2 * 3 * ... * (n-1) * n = (n-1)! * n = fact(n-1) * n
所以，fact(n)可以表示为 n * fact(n-1)，只有n=1时需要特殊处理。
于是，fact(n)用递归的方式写出来就是：
def fact(n):
if n==1:
return 1
return n * fact(n - 1)
38.定义默认参数
例如Python自带的 int() 函数，其实就有两个参数，我们既可以传一个参数，又可以传两个参数：
>>> int('123')
123
>>> int('123', 8)
83
int()函数的第二个参数是转换进制，如果不传，默认是十进制 (base=10)，如果传了，就用传入的参数。
假设计算平方的次数最多，我们就可以把 n 的默认值设定为 2：
def power(x, n=2):
s = 1
while n > 0:
n = n - 1
s = s * x
return s
这样一来，计算平方就不需要传入两个参数了：
由于函数的参数按从左到右的顺序匹配，所以默认参数只能定义在必需参数的后面。
39.定义可变参数
如果想让一个函数能接受任意个参数，我们就可以定义一个可变参数：
def fn(*args):
print args
可变参数的名字前面有个 * 号，我们可以传入0个、1个或多个参数给可变参数：
>>> fn()
>>> fn('a')
>>> fn('a', 'b')
可变参数也不是很神秘，Python解释器会把传入的一组参数组装成一个tuple传递给可变参数，因此，在函数内部，直接把变量 args 看成一个 tuple 就好了。
40.对list进行切片
取一个list的部分元素是非常常见的操作。比如，一个list如下：
>>> L = ['Adam', 'Lisa', 'Bart', 'Paul']
取前3个元素，用一行代码就可以完成切片：
>>> L[0:3]
['Adam', 'Lisa', 'Bart']
L[0:3]表示，从索引0开始取，直到索引3为止，但不包括索引3。
如果第一个索引是0，还可以省略：
>>> L[:3]
['Adam', 'Lisa', 'Bart']
也可以从索引1开始，取出2个元素出来：
>>> L[1:3]
['Lisa', 'Bart']
只用一个 : ，表示从头到尾：
>>> L[:]
['Adam', 'Lisa', 'Bart', 'Paul']
切片操作还可以指定第三个参数：
>>> L[::2]
['Adam', 'Bart']
第三个参数表示每N个取一个，上面的 L[::2] 会每两个元素取出一个来，也就是隔一个取一个。
把list换成tuple，切片操作完全相同，只是切片的结果也变成了tuple。
41.倒序切片
对于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。倒序切片包含起始索引，不包含结束索引。
42.对字符串切片
字符串 'xxx'和 Unicode字符串 u'xxx'也可以看成是一种list，每个元素就是一个字符。因此，字符串也可以用切片操作，只是操作结果仍是字符串：
>>> 'ABCDEFG'[:3]
'ABC'
>>> 'ABCDEFG'[-3:]
'EFG'
>>> 'ABCDEFG'[::2]
'ACEG'
43.索引迭代
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
44.迭代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
如果仔细阅读Python的文档，还可以发现，dict除了values()方法外，还有一个 itervalues() 方法，用 itervalues() 方法替代 values() 方法，迭代效果完全一样：
d = { 'Adam': 95, 'Lisa': 85, 'Bart': 59 }
print d.itervalues()
# <dictionary-valueiterator object at 0x106adbb50>
for v in d.itervalues():
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循环，而内部如何迭代我们通常并不用关心。
如果一个对象说自己可迭代，那我们就直接用 for 循环去迭代它，可见，迭代是一种抽象的数据操作，它不对迭代对象内部的数据有任何要求。
45.迭代dict的key和value
我们了解了如何迭代 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() 不占用额外的内存。
46.生成列表
要生成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创建出来，十分有用，多写几次，很快就可以熟悉这种语法。
47.条件过滤
如果我们只想要偶数的平方，可以加上 if 来筛选：
>>> [x * x for x in range(1, 11) if x % 2 == 0]
[4, 16, 36, 64, 100]
48.多层表达式
对于字符串 'ABC' 和 '123'，可以使用两层循环，生成全排列：
>>> [m + n for m in 'ABC' for n in '123']
['A1', 'A2', 'A3', 'B1', 'B2', 'B3', 'C1', 'C2', 'C3']
1）整数：Python可以处理任意大小的整数，当然包括负整数，在Python程序中，整数的表示方法和数学上的写法一模一样，例如：1，100，-8080，0，等等。
2）浮点数：浮点数也就是小数。整数和浮点数在计算机内部存储的方式是不同的，整数运算永远是精确的（除法难道也是精确的？是的！），而浮点数运算则可能会有四舍五入的误差。
3）字符串：字符串是以''或""括起来的任意文本。
4）布尔值：布尔值和布尔代数的表示完全一致，一个布尔值只有True、False两种值（请注意大小写）。
5）空值：空值是Python里一个特殊的值，用None表示。
此外，Python还提供了列表、字典等多种数据类型，还允许创建自定义数据类型。
2.print语句
print语句可以向屏幕上输出指定的文字。比如输出'hello, world'，用代码实现如下：
>>> print 'hello, world'
print语句也可以跟上多个字符串，用逗号“,”隔开，print会依次打印每个字符串，遇到逗号“,”会输出一个空格。
print也可以打印整数，或者计算结果：
>>> print 100 + 200
300 #运行结果
3.Python的注释
Python的注释以 # 开头，后面的文字直到行尾都算注释。
4.什么是变量
变量是用一个变量名表示，变量名必须是大小写英文、数字和下划线（_）的组合，且不能用数字开头。
在Python中，等号=是赋值语句，可以把任意数据类型赋值给变量，同一个变量可以反复赋值，而且可以是不同类型的变量，例如：
a = 123 # a是整数
a = 'imooc' # a变为字符串
这种变量本身类型不固定的语言称之为动态语言，与之对应的是静态语言。静态语言在定义变量时必须指定变量类型，如果赋值的时候类型不匹配，就会报错。Java是静态语言。
5.定义字符串
如果字符串本身包含'怎么办？比如我们要表示字符串 I'm OK ，这时，可以用" "括起来表示：
"I'm OK"
类似的，如果字符串包含"，我们就可以用' '括起来表示：
'Learn "Python" in imooc'
如果字符串既包含'又包含"怎么办？
这个时候，就需要对字符串的某些特殊字符进行“转义”，Python字符串用\进行转义。
要表示字符串 Bob said "I'm OK".
由于 ' 和 " 会引起歧义，因此，我们在它前面插入一个\表示这是一个普通字符，不代表字符串的起始，因此，这个字符串又可以表示为
'Bob said \"I\'m OK\".'
常用的转义字符还有：
\n 表示换行
\t 表示一个制表符
\\ 表示 \ 字符本身
6.raw字符串与多行字符串
如果一个字符串包含很多需要转义的字符，对每一个字符都进行转义会很麻烦。为了避免这种情况，我们可以在字符串前面加个前缀 r ，表示这是一个 raw 字符串，里面的字符就不需要转义了。例如：
r'\(~_~)/ \(~_~)/'
但是r'...'表示法不能表示多行字符串，也不能表示包含'和 "的字符串（为什么？）
如果要表示多行字符串，可以用'''...'''表示：
'''Line 1
Line 2
Line 3'''
上面这个字符串的表示方法和下面的是完全一样的：
'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!'''
7.Unicode字符串
Python在后来添加了对Unicode的支持，以Unicode表示的字符串用u'...'表示，比如：
print u'中文'
注意: 不加 u ，中文就不能正常显示。
如果中文字符串在Python环境下遇到 UnicodeDecodeError，这是因为.py文件保存的格式有问题。可以在第一行添加注释
# -*- coding: utf-8 -*-
目的是告诉Python解释器，用UTF-8编码读取源代码。然后用Notepad++ 另存为... 并选择UTF-8格式保存。此时不需要加u。
8.整数和浮点数
Python支持对整数和浮点数直接进行四则混合运算，运算规则和数学上的四则运算规则完全一致。
使用括号可以提升优先级，这和数学运算完全一致，注意只能使用小括号，但是括号可以嵌套很多层。
和数学运算不同的地方是，Python的整数运算结果仍然是整数，浮点数运算结果仍然是浮点数，但是整数和浮点数混合运算的结果就变成浮点数了。
为什么要区分整数运算和浮点数运算呢？这是因为整数运算的结果永远是精确的，而浮点数运算的结果不一定精确，因为计算机内存再大，也无法精确表示出无限循环小数，比如 0.1 换成二进制表示就是无限循环小数。
Python的整数除法，即使除不尽，结果仍然是整数，余数直接被扔掉。不过，Python提供了一个求余的运算 % 可以计算余数。
9.布尔类型
在Python中，布尔类型还可以与其他数据类型做 and、or和not运算，请看下面的代码：
a = True
print a and 'a=T' or 'a=F'
计算结果不是布尔类型，而是字符串 'a=T'，这是为什么呢？
因为Python把0、空字符串''和None看成 False，其他数值和非空字符串都看成 True，所以：
True and 'a=T' 计算结果是 'a=T'
继续计算 'a=T' or 'a=F' 计算结果还是 'a=T'
要解释上述结果，又涉及到 and 和 or 运算的一条重要法则：短路计算。
1. 在计算 a and b 时，如果 a 是 False，则根据与运算法则，整个结果必定为 False，因此返回 a；如果 a 是 True，则整个计算结果必定取决与 b，因此返回 b。
2. 在计算 a or b 时，如果 a 是 True，则根据或运算法则，整个计算结果必定为 True，因此返回 a；如果 a 是 False，则整个计算结果必定取决于 b，因此返回 b。
所以Python解释器在做布尔运算时，只要能提前确定计算结果，它就不会往后算了，直接返回结果。
10.创建list
Python内置的一种数据类型是列表：list。list是一种有序的集合，可以随时添加和删除其中的元素。
比如，列出班里所有同学的名字，就可以用一个list表示：
>>> ['Michael', 'Bob', 'Tracy']
构造list非常简单，按照上面的代码，直接用 [ ] 把list的所有元素都括起来，就是一个list对象。通常，我们会把list赋值给一个变量，这样，就可以通过变量来引用list：
>>> classmates = ['Michael', 'Bob', 'Tracy']
>>> classmates # 打印classmates变量的内容
['Michael', 'Bob', 'Tracy']
由于Python是动态语言，所以list中包含的元素并不要求都必须是同一种数据类型，我们完全可以在list中包含各种数据：
>>> L = ['Michael', 100, True]
11.按照索引访问list
需要特别注意的是，索引从 0 开始，也就是说，第一个元素的索引是0，第二个元素的索引是1，以此类推。
因此，要打印第一名同学的名字，用 L[0]:
>>> print L[0]
12.倒序访问list
Bart同学是最后一名，俗称倒数第一，所以，我们可以用 -1 这个索引来表示最后一个元素：
>>> print L[-1]
13.list添加新元素
现在，班里有3名同学：
>>> L = ['Adam', 'Lisa', 'Bart']
今天，班里转来一名新同学 Paul，如何把新同学添加到现有的 list 中呢？
第一个办法是用 list 的 append() 方法，把新同学追加到 list 的末尾：
>>> L = ['Adam', 'Lisa', 'Bart']
>>> L.append('Paul')
append()总是把新的元素添加到 list 的尾部。
如果 Paul 同学表示自己总是考满分，要求添加到第一的位置，怎么办？
方法是用list的 insert()方法，它接受两个参数，第一个参数是索引号，第二个参数是待添加的新元素：
>>> L = ['Adam', 'Lisa', 'Bart']
>>> L.insert(0, 'Paul')
14.list删除元素
Paul同学刚来几天又要转走了，那么我们怎么把Paul 从现有的list中删除呢？
如果Paul同学排在最后一个，我们可以用list的pop()方法删除：
>>> L = ['Adam', 'Lisa', 'Bart', 'Paul']
>>> L.pop()
'Paul'
pop()方法总是删掉list的最后一个元素，并且它还返回这个元素，所以我们执行 L.pop() 后，会打印出 'Paul'。
如果Paul同学不是排在最后一个怎么办？比如Paul同学排在第三：
>>> L = ['Adam', 'Lisa', 'Paul', 'Bart']
要把Paul踢出list，我们就必须先定位Paul的位置。由于Paul的索引是2，因此，用 pop(2)把Paul删掉。
15.list替换元素
假设现在班里仍然是3名同学：
>>> L = ['Adam', 'Lisa', 'Bart']
现在，Bart同学要转学走了，碰巧来了一个Paul同学，要更新班级成员名单，我们可以先把Bart删掉，再把Paul添加进来。
另一个办法是直接用Paul把Bart给替换掉：
>>> L[2] = 'Paul'
16.创建tuple
tuple是另一种有序的列表，中文翻译为“ 元组 ”。tuple 和 list 非常类似，但是，tuple一旦创建完毕，就不能修改了。
同样是表示班里同学的名称，用tuple表示如下：
>>> t = ('Adam', 'Lisa', 'Bart')
创建tuple和创建list唯一不同之处是用( )替代了[ ]。
现在，这个 t 就不能改变了，tuple没有 append()方法，也没有insert()和pop()方法。所以，新同学没法直接往 tuple 中添加，老同学想退出 tuple 也不行。
获取 tuple 元素的方式和 list 是一模一样的，我们可以正常使用 t[0]，t[-1]等索引方式访问元素，但是不能赋值成别的元素。
17.创建单元素tuple
tuple和list一样，可以包含 0 个、1个和任意多个元素。
包含 0 个元素的 tuple，也就是空tuple，直接用 ()表示：
>>> t = ()
>>> print t
()
创建包含1个元素的 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。
18.if语句
注意: Python代码的缩进规则。具有相同缩进的代码被视为代码块。缩进请严格按照Python的习惯写法：4个空格，不要使用Tab，更不要混合Tab和空格，否则很容易造成因为缩进引起的语法错误。
注意: if 语句后接表达式，然后用:表示代码块开始。如果你在Python交互环境下敲代码，还要特别留意缩进，并且退出缩进需要多敲一行回车。
19.if-else
if age >= 18:
print 'adult'
else:
print 'teenager'
注意: else 后面有个“:”。
20.if-elif-else
elif 意思就是 else if。
21.for循环
L = ['Adam', 'Lisa', 'Bart']
for name in L:
print name
22.while循环
N = 10
x = 0
while x < N:
print x
x = x + 1
23.break退出循环
用 for 循环或者 while 循环时，如果要在循环体内直接退出循环，可以使用 break 语句。
比如计算1至100的整数和，我们用while来实现：
sum = 0
x = 1
while True:
sum = sum + x
x = x + 1
if x > 100:
break
print sum
24.continue继续循环
在循环过程中，可以用break退出当前循环，还可以用continue跳过后续循环代码，继续下一次循环。
25.什么是dict
用 dict 表示“名字”-“成绩”的查找表如下：
d = {
'Adam': 95,
'Lisa': 85,
'Bart': 59
}
我们把名字称为key，对应的成绩称为value，dict就是通过 key 来查找 value。
花括号 {} 表示这是一个dict，然后按照 key: value, 写出来即可。最后一个 key: value 的逗号可以省略。
由于dict也是集合，len() 函数可以计算任意集合的大小。
26.访问dict
可以简单地使用 d[key] 的形式来查找对应的 value，这和 list 很像，不同之处是，list 必须使用索引返回对应的元素，而dict使用key。
注意: 通过 key 访问 dict 的value，只要 key 存在，dict就返回对应的value。如果key不存在，会直接报错：KeyError。
要避免 KeyError 发生，有两个办法：
一是先判断一下 key 是否存在，用 in 操作符：
if 'Paul' in d:
print d['Paul']
二是使用dict本身提供的一个 get 方法，在Key不存在的时候，返回None。
27.dict的特点
dict的第一个特点是查找速度快，无论dict有10个元素还是10万个元素，查找速度都一样。而list的查找速度随着元素增加而逐渐下降。
不过dict的查找速度快不是没有代价的，dict的缺点是占用内存大，还会浪费很多内容，list正好相反，占用内存小，但是查找速度慢。
由于dict是按 key 查找，所以，在一个dict中，key不能重复。
dict的第二个特点就是存储的key-value序对是没有顺序的！这和list不一样。
dict的第三个特点是作为 key 的元素必须不可变，Python的基本类型如字符串、整数、浮点数都是不可变的，都可以作为 key。但是list是可变的，就不能作为 key。
28.更新dict
dict是可变的，也就是说，我们可以随时往dict中添加新的 key-value。比如已有dict：
d = {
'Adam': 95,
'Lisa': 85,
'Bart': 59
}
要把新同学'Paul'的成绩 72 加进去，用赋值语句：
>>> d['Paul'] = 72
如果 key 已经存在，则赋值会用新的 value 替换掉原来的 value。
29.遍历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的值。
30.什么是set
set 持有一系列元素，这一点和 list 很像，但是set的元素没有重复，而且是无序的，这点和 dict 的 key很像。
创建 set 的方式是调用 set() 并传入一个 list，list的元素将作为set的元素：
>>> s = set(['A', 'B', 'C'])
31.访问set
由于set存储的是无序集合，所以我们没法通过索引来访问。
访问 set中的某个元素实际上就是判断一个元素是否在set中。
例如，存储了班里同学名字的set：
>>> s = set(['Adam', 'Lisa', 'Bart', 'Paul'])
我们可以用 in 操作符判断：
Bart是该班的同学吗？
>>> 'Bart' in s
True
32.set的特点
set的内部结构和dict很像，唯一区别是不存储value，因此，判断一个元素是否在set中速度很快。
set存储的元素和dict的key类似，必须是不变对象，因此，任何可变对象是不能放入set中的。
最后，set存储的元素也是没有顺序的。
33.更新set
由于set存储的是一组不重复的无序元素，因此，更新set主要做两件事：
一是把新的元素添加到set中，二是把已有元素从set中删除。
添加元素时，用set的add()方法。如果添加的元素已经存在于set中，add()不会报错，但是不会加进去了。
删除set中的元素时，用set的remove()方法。如果删除的元素不存在set中，remove()会报错，所以用add()可以直接添加，而remove()前需要判断。
34.调用函数
Python内置了很多有用的函数，我们可以直接调用。
要调用一个函数，需要知道函数的名称和参数，比如求绝对值的函数 abs，它接收一个参数。
也可以在交互式命令行通过 help(abs) 查看abs函数的帮助信息。
而比较函数 cmp(x, y) 就需要两个参数，如果 x<y，返回 -1，如果 x==y，返回 0，如果 x>y，返回 1。
Python内置的常用函数还包括数据类型转换函数，比如 int()函数可以把其他数据类型转换为整数。str()函数把其他类型转换成 str。
35.编写函数
在Python中，定义一个函数要使用 def 语句，依次写出函数名、括号、括号中的参数和冒号:，然后，在缩进块中编写函数体，函数的返回值用 return 语句返回。
36.函数返回多值
import math
def move(x, y, step, angle):
nx = x + step * math.cos(angle)
ny = y - step * math.sin(angle)
return nx, ny
用print打印返回结果，原来返回值是一个tuple！
但是，在语法上，返回一个tuple可以省略括号，而多个变量可以同时接收一个tuple，按位置赋给对应的值，所以，Python的函数返回多值其实就是返回一个tuple，但写起来更方便。
37.递归函数
在函数内部，可以调用其他函数。如果一个函数在内部调用自身本身，这个函数就是递归函数。
举个例子，我们来计算阶乘 n! = 1 * 2 * 3 * ... * n，用函数 fact(n)表示，可以看出：
fact(n) = n! = 1 * 2 * 3 * ... * (n-1) * n = (n-1)! * n = fact(n-1) * n
所以，fact(n)可以表示为 n * fact(n-1)，只有n=1时需要特殊处理。
于是，fact(n)用递归的方式写出来就是：
def fact(n):
if n==1:
return 1
return n * fact(n - 1)
38.定义默认参数
例如Python自带的 int() 函数，其实就有两个参数，我们既可以传一个参数，又可以传两个参数：
>>> int('123')
123
>>> int('123', 8)
83
int()函数的第二个参数是转换进制，如果不传，默认是十进制 (base=10)，如果传了，就用传入的参数。
假设计算平方的次数最多，我们就可以把 n 的默认值设定为 2：
def power(x, n=2):
s = 1
while n > 0:
n = n - 1
s = s * x
return s
这样一来，计算平方就不需要传入两个参数了：
由于函数的参数按从左到右的顺序匹配，所以默认参数只能定义在必需参数的后面。
39.定义可变参数
如果想让一个函数能接受任意个参数，我们就可以定义一个可变参数：
def fn(*args):
print args
可变参数的名字前面有个 * 号，我们可以传入0个、1个或多个参数给可变参数：
>>> fn()
>>> fn('a')
>>> fn('a', 'b')
可变参数也不是很神秘，Python解释器会把传入的一组参数组装成一个tuple传递给可变参数，因此，在函数内部，直接把变量 args 看成一个 tuple 就好了。
40.对list进行切片
取一个list的部分元素是非常常见的操作。比如，一个list如下：
>>> L = ['Adam', 'Lisa', 'Bart', 'Paul']
取前3个元素，用一行代码就可以完成切片：
>>> L[0:3]
['Adam', 'Lisa', 'Bart']
L[0:3]表示，从索引0开始取，直到索引3为止，但不包括索引3。
如果第一个索引是0，还可以省略：
>>> L[:3]
['Adam', 'Lisa', 'Bart']
也可以从索引1开始，取出2个元素出来：
>>> L[1:3]
['Lisa', 'Bart']
只用一个 : ，表示从头到尾：
>>> L[:]
['Adam', 'Lisa', 'Bart', 'Paul']
切片操作还可以指定第三个参数：
>>> L[::2]
['Adam', 'Bart']
第三个参数表示每N个取一个，上面的 L[::2] 会每两个元素取出一个来，也就是隔一个取一个。
把list换成tuple，切片操作完全相同，只是切片的结果也变成了tuple。
41.倒序切片
对于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。倒序切片包含起始索引，不包含结束索引。
42.对字符串切片
字符串 'xxx'和 Unicode字符串 u'xxx'也可以看成是一种list，每个元素就是一个字符。因此，字符串也可以用切片操作，只是操作结果仍是字符串：
>>> 'ABCDEFG'[:3]
'ABC'
>>> 'ABCDEFG'[-3:]
'EFG'
>>> 'ABCDEFG'[::2]
'ACEG'
43.索引迭代
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
44.迭代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
如果仔细阅读Python的文档，还可以发现，dict除了values()方法外，还有一个 itervalues() 方法，用 itervalues() 方法替代 values() 方法，迭代效果完全一样：
d = { 'Adam': 95, 'Lisa': 85, 'Bart': 59 }
print d.itervalues()
# <dictionary-valueiterator object at 0x106adbb50>
for v in d.itervalues():
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循环，而内部如何迭代我们通常并不用关心。
如果一个对象说自己可迭代，那我们就直接用 for 循环去迭代它，可见，迭代是一种抽象的数据操作，它不对迭代对象内部的数据有任何要求。
45.迭代dict的key和value
我们了解了如何迭代 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() 不占用额外的内存。
46.生成列表
要生成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创建出来，十分有用，多写几次，很快就可以熟悉这种语法。
47.条件过滤
如果我们只想要偶数的平方，可以加上 if 来筛选：
>>> [x * x for x in range(1, 11) if x % 2 == 0]
[4, 16, 36, 64, 100]
48.多层表达式
对于字符串 'ABC' 和 '123'，可以使用两层循环，生成全排列：
>>> [m + n for m in 'ABC' for n in '123']
['A1', 'A2', 'A3', 'B1', 'B2', 'B3', 'C1', 'C2', 'C3']
471
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
