变量和数据类型
一、整数
十六进制用0x前缀和0-9，a-f表示，例如：0xff00,0xa5b4c3d2
整数和浮点数混合运算的结果变成浮点数。整数除法，除不尽时，结果仍是整数，余数直接被扔掉。同时，Python提供了一个求余的运算%可以计算余数11%4
如果要计算11/4的精确结果，按照“整数和浮点数混合运算的结果是浮点数”的法则，把两个数中的一个变成浮点数再运算即可。
二、浮点数
把10用e表示，1.23x10^9就是1.23e9,0.000012可以写成1.2e-5
整数和浮点数在计算机内部存储的方式是不同的，整数运算永远是精确的（包括除法运算），而浮点数运算则可能会有四舍五入的误差。
三、字符串
四、布尔值
Python把0、空字符串''和None看成False，其他数值和非空字符串都看成True
a = True print a and '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解释器在做布尔运算时，只要提前确定计算结果，直接返回结果。
五、空值
空值是Python里一个特殊的值，用None表示
此外，Python还提供了列表、字典等多种数据类型，还允许创建自定义数据类型。
print语句
多个字符串，用逗号“，”隔开，输出空格
变量
变量名必须是大小写英文、数字和下划线（_）的组合，且不能用数字开头
转义符
字符串包括 '和“，需要用对某些特殊字符进行”转义“，转义字符不计入字符串的内容中
#常用转义字符
表示换行
表示一个制表符
\ 表示 字符本身
raw与多行字符串
多行字符串转义，在前面加前缀r，表示这是一个raw字符串，里面的字符不需要转义。但r'. . .'不能表示多行字符串，也不能表示包含’和“的字符串
表示多行字符串，可以用'''...'''
'''Line 1 Line 2 Line 3''' #等同于 ‘Line 1 Line 2 Line 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，0-255被用来表示大小写英文字母、数字和一些符号，这个编码表被称为ASCII编码。
要表示中文，至少需要两个字节，而且不能喝ASCII编码冲突，所以，中国制订了GB2312编码。类似的，日文和韩文等其他语言也有这个问题。为了统一所有文字的编码，Unicode应运而生。Unicode通常用两个字节表示一个字符，原有的英文编码从单字节变成双字节，只需要把高字节全部填为0即可。
因为Python的诞生比Unicode标准发布的时间要早，所以最早额Python只支持ASCII编码。后来添加了对Unicode的支持，以Unicode表示的字符串用u'...'
print u'中文'
Unicode字符串除了多一个u外，与普通字符串没有区别，转义字符和多行表示仍然有效。
如果中文字符串在Python环境下遇到UnicodeDecodeError，这是因为.py文件保存的格式有问题。可以在第一行添加注释
# - *-coding: utf-8-*-
List和Tuple类型
创建List
Python内置的一种数据类型是列表：list。list是一种有序的集合，可以随时添加和删除其中的元素。
由于Python是动态语言，所以list中包含的元素并不要求都必须是同一种数据类型。
按照索引访问list
索引从0开始，第一个元素的索引是0，第二个元素的索引是1，以此类推。
倒序访问list
可以用-1这个索引来表示最后一个元素，倒数第二用-2，以此类推。
添加新元素
用list的append()方法，把新元素追加到list的末尾。append()总是把新的元素添加到list的尾部。
用list的insert()方法，它接受两个参数，第一个参数是索引号，第二个参数是待添加的新元素
L = ['Adam','Lisa','Bart'] L.insert(0,'Paul') print L ['Paul','Adam','Lisa','Bart'] # L.insert(0,'Paul')，'Paul'将被添加到索引为0的位置，其它元素自动向后移动一位。
从list删除元素
如果元素在最后一位，可以用list的pop()方法删除。pop()方法总是删除list的最后一个元素，并且它还返回这个元素，所以执行L.pop()后，会打印这个元素。
如果元素不是最后一位，则先定位元素位置，比如第三位，再用pop(2)把元素删除。后面的元素位置自动往前移动一位。
替换元素
对list中的某一个索引赋值，可以直接用新的元素替换掉原来的元素，list包含的元素个数保持不变。由于末尾元素可以用-1做索引，因此，可以用L[-1]完成替换。
创建tuple
tuple是另一种有序的列表，中文为“元组”。tuple和list非常类似，但是，tuple一旦创建完毕，就不能修改。
创建tuple和创建list唯一不同之处是用()替代[]
创建单元素tuple
包含0个元素的tuple，也就是空tuple，直接用()表示
t = () print t # () t = (1) print t # 1
因为()既可以表示tuple，又可以作为括号表示运算时的优先级，结果(1)被Python解释器计算出结果1，导致得到的不是tuple，而是整数1。
正是因为()定义单元素的tuple有歧义，所以Python规定，单元素tuple要多加一个逗号”,”，这样就避免了歧义。
t = (1,) print t # (1,)
Python在打印单元素tuple时，自动添加了一个“，”,更明确地告知这是一个tuple。
“可变”的tuple
#“可变”的tuple
t = ('a','b',['A','B'])
注意到t有3个元素：’a’，’b’和一个list：[‘A’,’B’]。list作为一个整体是tuple的第3个元素。list对象可以通过t[2]获得。
tuple一开始指向的list并没有改成别的list，所以，tuple所谓的“不变”是指，tuple的每个元素，指向永远不变。即指向’a’，就不能改成指向’b’，指向一个list，就不能改成指向其他对象，但指向的这个list本身是可变的。
条件判断和循环
if语句
注意：Python代码的缩进规则。具有相同缩进的代码被视为代码块，if语句后接表达式，用：表示代码块开始。
Python缩进的习惯写法：4个空格，不要使用Tab，更不要混合Tab和空格，否则很容易造成因为缩进引起的语法错误。
如果在Python交互环境下写代码，还要特别留意缩进，并且推出缩进需要多敲一行回车
if-else
if age >= 18:
print 'adult'
else:
print 'teenager'
if-elif-else
特别注意：这一系列条件判断会从上到下依次判断，如果某个判断为True，执行完对应的代码块，后面的条件判断就直接忽略，不再执行。
if age >= 18:
print 'adult'
elif age >= 6:
print 'teenager'
elif age >= 3:
print 'kid'
else:
print 'baby'
for循环
L = ['Adam','Lisa','Bart'] for name in L: print name
注意：name这个变量是在for循环中定义的，依次取出list中的每一个元素，并把元素赋值给name，然后执行for循环体。
while循环
break退出循环
2的N次方2**n，判断偶数n%2 == 0
continue继续循环
在循环过程中，可以用break退出当前循环，还可以用continue跳过后续循环代码，继续下一次循环。
多重循环
Dict和Set类型
字典dict
用dict表示“名字”-“成绩”的查找表：
d={
'Adam':95,
'Lisa': 85,
'Bart': 59
}
把名字称为key，对应的成绩称为value，dict通过key来查找value。
花括号{}表示这是一个dict，然后按照key:value，写出来即可。最后一个key:value的逗号可以省略。
由于dict也是集合，len()函数可以计算任意集合的大小
访问dict
使用d[key]的形式来查找对应的value，这和list很像，不同之处是，list必须使用索引返回对应的元素，而dict使用key
要避免KeyError发生，有两个办法：
一是先判断一下key是否存在，用in操作符：
if 'Paul' in d:
print d['Paul']
如果’Paul’不存在，if语句判断为False
二是使用dict本身提供的一个get方法，在key不存在的时候，返回None：
print d.get('Paul')
# None
dict的特点
dict的第一个特点是查找速度快，无论dict有10个元素还是10万个元素，查找速度都一样。而list的查找速度随着元素增加而逐渐下降。
不过，dict的查找速度快不是没有代价的，dict的缺点是占用内存大，还会浪费很多内容，list正好相反。
由于dict是按key查找，所以，在一个dict中，key不能重复。
dict的第二个特点就是存储的key-value序对是没有顺序的，这和list不一样。dict内部是无序的，不能用dict存储有序的集合。
dict的第三个特点是作为key的元素必须不可变，Python的基本类型如字符串、整数、浮点数都是不可变的，都可以作为key。但list是可变的，就不能作为key。
不可变这个限制仅作用于key，value是否可变无所谓。
更新dict
d={
'Adam':95,
'Lisa':85,
'Bart':59
}
#把新的元素加进去，用赋值语句
d['Paul'] = 72
遍历dict
#使用for循环遍历如下的dict，打印出name:score来。
d={
'Adam':95,
'Lisa':85,
'Bart':59
}
for key in d:
print key,':',d[key]
什么是set
dict的作用是建立一组key和一组value的映射关系，dict的key是不能重复的。
set持有一系列元素，这一点和list很像，但是set的元素没有重复，而且是无序的，这点和dict的key很像。
创建set的方式是调用set()并传入一个list，list的元素将作为set的元素，set内部存储的元素是无序的。set不能包含重复的元素
s = set(['A','B','C'])
访问set
由于set存储的是无需集合，所以无法通过索引来访问。访问set中的某个元素实际上就是判断一个元素是否在set中。可以用in操作符判断，区别大小写
set的特点set的内部结构和dict很像，唯一区别是不存储value，因此，判断一个元素是否在set中速度很快。
set存储的元素和dict的key类似，必须是不变对象，因此，任何可变对象不能放入set中。
最后，set存储的元素也是没有顺序的
遍历set
注意：for循环在遍历set时，元素的顺序和list的顺序很可能不同，而且不同的机器上运行的结果也可能不同。
#用for循环遍历如下的set，打印出name:score来。
s = set([('Adam',95),('Lisa',85),('Bart',59)])
for x in s:
print x[0],':',x[1]
更新set
由于set存储的是一组不重复的无序元素，因此，更新set主要做两件事：一是新的元素添加到set中，二是把已有元素从set中删除。
添加元素时，用set的add()方法，如果添加的元素已经存在于set中，add()不会报错，但是元素不会加入set中。
s = set([1,2,3]) s.add(4) print s
删除set中的元素时，用set的remove()方法，如果删除的元素不存在set中，remove()会报错。
所以用add()可以直接添加，而remove()前需要判断。
#针对下面的set，给定一个list，对list中的每一个元素，如果在list中，就将其删除，如果不在set中，就添加进去。
s = set(['Adam','Lisa','Paul'])
L = ['Adam','Lisa','Bart','Paul']
for name in L:
if name in s:
s.remove(name)
else:
s.add(name)
print s
函数
调用函数
调用函数的时候，如果传入的参数数量不对，会报TypeError的错误，并且Python会明确地告诉你：abd()有且仅有1个参数，但给出了两个。
如果传入的参数数量是对的，但参数类型不能被函数所接受，也会报TypeError的错误，并且给出错误信息：str是错误的参数类型。
比较函数cmp(x,y)就需要两个参数，如果x < y，返回-1；如果x == y，返回0；如果x > y，返回1
Python内置的常用函数还包括数据类型转换函数，比如，int()函数可以把其他数据类型转换为整数，str()函数把其他类型转换为str
#sum()函数接受一个list作为参数，并返回list所有元素之和。请计算1*1+2*2+3*3+...+100*100
L = []
x = 1
while x <= 100:
L.append(x * x)
x = x + 1
print sum(L)
编写函数
在Python中，定义一个函数使用def语句，依次写出函数名、括号、括号中的参数和冒号:，然后，在缩进块中编写函数体，函数的返回值用return语句返回。
如果没有return语句，函数执行完毕后也会返回结果，只是结果为None。return None可以简写为return
#定义一个square_of_sum函数，它接受一个list，返回list中每个元素平方的和。
def square_of_sum(L):
sum = 0
for x in L:
sum = sum + x*x
return sum
print square_of_sum([1,2,3,4,5])
返回多值math包提供了sin()和cos()函数，可以先用import引用它。
Python的函数返回多值其实就是返回一个tuple
递归函数
如果一个函数在内部调用自身，这个函数就是递归函数。
计算阶乘用函数fact()表示，fact()可以表示为n*fact(n-1)，只有n=1时需要特殊处理。
使用递归函数需要注意防止栈溢出。在计算机中，函数调用是通过栈(stack)这种数据结构实现的，每当进入一个函数调用，栈就会加一层栈帧，每当函数返回，栈就会减一层栈帧。由于栈的大小不是无限的，所以，递归调用的次数过多，会导致栈溢出。
定义默认参数
Python自带的int()函数，其实有两个参数，既可以传一个参数，又可以传两个参数。int()函数的第二个参数是转换进制。
函数的默认参数的作用是简化调用，只需要把必须的参数传进去，又可以传入额外的参数覆盖默认参数值。
由于函数的参数按从左到右的顺序匹配，所以默认参数只能定义在必需参数的后面
#定义一个greet()函数，包含一个默认参数，如果没有传入，打印‘Hello,world.’，如果传入，打印'Hello,xxx.'
def greet(name='World'):
print 'Hello,'+name+'.'
greet ()
greet('Bart')
定义可变参数
如果让一个函数能接受任意个参数，可以定义一个可变参数：
def fn(*args)
print args
Python解释器把传入的一组参数组装成一个tuple传递给可变参数，因此，在函数内部，直接把变量args看成一个tuple
#编写接受可变参数的average()函数。
def average(*args):
sum = 0.0
if len(args) == 0:
return sum
for x in args:
sum = sum + x
return sum / len(args)
print average()
print average(1,2)
切片
对list进行切片
对于经常取指定索引范围的操作，用循环十分繁琐，因此，Python提供了切片Slice操作符，能大大简化这种操作。
#取前3个元素，用一行代码可以完成切片 L[0:3] 表示，从索引0开始取，直到索引3为止，但不包括索引3 L[:3] 如果第一个索引是0，还可以省略 L[1:3] 从索引1开始，取出2个元素 L[:] 表示从头到尾，实际上复制了一个新list 切片操作还可以指定第三个参数 L[::2] 第三个参数表示每N个取一个，上面的L[::2]会每两个元素取出一个，也就是隔一个取一个 把list换成tuple，切片操作完全相同。 #range()函数可以创建一个数列： range(1,101) [1,2,3,...,100] 利用切片，取出 1、3的倍数 2、不大于50的5的倍数 L = range(1，101) print L[2::3] print L[4:50:5]或print L[-10:][4::5]
倒序切片
倒数第一个元素的索引是-1。倒叙切片包含起始索引，不包含结束索引。
#利用倒序切片对1-100的数列取出： 最后10个5的倍数 L = range(1,101) print L[4::5][-10:]
对字符串切片
Python没有针对字符串的截取函数，只需要切片一个操作就可以完成。
字符串upper()方法可以把字符变成大写字母：'abc'.upper()–>ABC，但它会把所有字母都变成大写。
#设计一个函数，接受一个字符串，然后返回一个仅首字母变成大写的字符串
def firstCharUpper(s):
return s[:1].upper()+s[1:]
print firstCharUpper('hello')
迭代
在Python中，如果给定一个list或tuple，可以通过for循环来遍历这个list或tuple，这种遍历称为迭代(Iteration)。在Python中，迭代是通过for...in来完成。可以看出，Python的for循环抽象程序程度要高于Java的for循环。
for (i=0;i<list.length;i++){
n=list[i];
}
因为Python的for循环不仅可以用在list或tuple上，还可以作用在其他任何可迭代对象上。
因此，迭代操作就是对于一个集合，无论该集合是有序还有无序，用for循环总是可以依次取出集合的每一个元素。
注意：集合是指包含一组元素的数据结构，已经介绍的包括： 1、有序集合：list,tuple,str和unicode； 2、无序集合：set 3、无序集合并且具有key-value 对：dict
迭代是一个动词，它指的是一种操作，在Python中，就是for循环。
迭代与按下标访问数组最大的不同是，后者是一种具体的迭代实现方式，而前者只关心迭代结果，根本不关心迭代内部是如何实现。
索引迭代
python中，迭代永远是取出元素本身，而非元素的索引
对于有序集合，元素确实是有索引的。方法是使用enumerate()函数
L = ['Adam','Lisa','Bart','Paul']
for index,name in enumerate(L):
print index,'-',name
使用enumerate()函数，可以在for循环中同时绑定索引index和元素name。但是，这不是enumerate()的特殊语法。实际上，enumerate()函数把：
['Adam','Lisa','Bart','Paul']
变成了类似：
[(0,'Adam'),(1,'Lisa'),(2,'Bart'),(3,'Paul')]因此，迭代的每一个元素实际上是一个tuple：
for t in enumerate(L):
index = t[0]
name = t[1]
print index,'-',name
每个tuple元素都包含两个元素，for循环又可以进一步简写为：
for index，name in enumerate(L):
print index,'-',name
这样不但代码更简单，而且还少了两条赋值语句。
可见，索引迭代不是真的按索引访问，而是由enumerate()函数自动把每个元素变成(index,element)这样的tuple，再迭代，就同时获得了索引和元素本身。
#zip()函数可以把两个list变成一个list： zip([1,2,3],['A','B','C']) [(1,'A'),(2,'B'),(3,'C')]
迭代dict的value
dict对象本身就是可迭代对象，用for循环直接迭代dict，可以每次拿到dict的一个key。
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
dict除了values()方法外，还有一个itervalues()方法，用itervalues()方法替代values()方法，迭代效果完全一样
两个方法不同之处：
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循环去迭代它，可见，迭代是一种抽象的数据操作，它不对迭代对象内部的数据有任何要求。
迭代dict的key和value
在一个for循环中，同时迭代key和value。dict对象的items()方法返回的值。
print d.items()
items()方法把dict对象转换成包含tuple的list，对这个list进行迭代，可以同时获得key和value
for key,value in d.items():
print key,':',value
和values()有一个itervalues()类似，items()也有一个对应的iteritems()，iteritems()不把dict转换成list，而是在迭代过程中不断给出tuple，所以，iteritems()不占用额外的内存。
列表生成式
生成列表
#生成[1x1,2x2,...,10x10]
方法一是循环：
L = []
for x in range(1,11):
L.append(x*x)
方法二：循环太繁琐，而列表生成式则可以用一行语句代替循环生成上面的list：
[x*x for x in range(1,11)]
这种写法就是Python特有的列表生成式。利用列表生成式，可以以非常简洁的代码生成list
写列表生成式时，把要生成的元素x*x放到前面，后面跟for循环，就可以了把list创建出来。
#利用列表生成式生成列表[1x2,3x4,...,99x100] print [x*(x+1) for x in range(1,100,2)]
复杂表达式
使用for循环的迭代不仅可以迭代普通的list，还可以迭代dict。
d = {'Adam':95,'Lisa':85,'Bart':59}
#可以通过一个复杂的列表生成式把它变成一个HTML表格
tds = ['<tr><td>%s</td><td>%s</td></tr>' % (name,score) for name,score in d.iteritems()]
print '<table>'
print '<tr><th>Name</th><th>Score</th></tr>'
print '
'.join(tds)
print '</table>'
注：字符串可以通过%进行格式化，用指定的参数替代%s。字符串的join()方法可以把一个list拼接成一个字符串。
把打印出来的结果保存为html文件，即可在浏览器中看到效果。
条件过滤
列表生成式的for循环后面还可以加上if判断
1，isinstance(x,str)可以判断变量x是否是字符串
2，字符串的upper()方法可以返回大写的字母
#编写一个函数，它接受一个list，然后把list中的所有字符串变成大写后返回，非字符串元素将被忽略。
def toUppers(L):
return [str.upper(x) for x in L if isinstance(x,str)]
print toUppers(['Hello','world',101])
多层表达式
for循环可以嵌套，因此，在列表生成式中，也可以用多层for循环来生成列表。
#对于字符串'ABC'和'123'，可以使用两层循环，生成全排列
[m+n for m in 'ABC' for n in '123']
#翻译成循环代码
L=[]
for m in 'ABC':
for n in '123':
L.append(m+n)
#利用3层for循环的列表生成式，找到对称的3位数。
print [int(str(a)+str[b]+str[c]) for a in range(1,10) for b in range(10) for c in range(1,10) if a==c]