编码
assic(只有英文及特殊字符) gb2312(6700) gbk(1995-21000) gb18030(27000) 万国码：unicode
python2.x默认为assic编码
python3.x默认为utf-8编码
改变编码：#-*- coding:utf-8 -*- (告诉py解释器，后面的代码用utf8来解释)
msg = "中国“
msg.decode(encoding="utf-8").encode(encoding="gbk") 先解码为unicode，然后在编码为gbk
文件
r：只读模式（默认）
w：只写模式（不可读，文件不存在则创建，存在则覆盖原内容）
a：追加模式（可读，文件不存在则创建，存在则只在文件末尾追加内容）
+表示可以同时读写某个文件
r+:可读写文件（可读、可写、可追加）
w+:写读（清空原文件，再写入新内容**尽量少用**）
a+:同a
U表示在读取时，可以将\r \n \r\n自动转换成\n（与r或r+模式同时使用）
rU
r+U
b表示处理二进制文件（如：FTP发送上传ISO镜像文件，linux可忽略，windows处理二进制文件时需注明）
rb
wb
ab
-----------------------------------------------------------------------------------
f = open("test","r+",encoding="utf-8")
print("cursor:",f.tell())
print(f.read())
f.write("test")
f.close()
open()#如果encoding不声明，默认使用操作系统的编码来解释文件
f.tell()#光标所在位置
f.seek(10)#将光标移动10个字节
f.read(10)#读取10个字符
f.flush()#将内存中的数据刷新至硬盘，一般用于打印实时日志
集合
name = {}
天生去重
关系运算
a = {1,2,3,4,5,6,7,}
b = {8,5,6,98,644,2,3}
#差集
print(a - b)
print(a.difference(b))
print(b - a)
print(b.difference(a))
##交集
print(b & a)
print(a.intersection(b))
print(b.intersection(a))
#并集
print(a | b)
print(a.union(b))
print(b.union(a))
#对称差集
print(a ^ b)
print(a.symmetric_difference(b))
print(b.symmetric_difference(a))
a = {1,2,3}
b = {1,2,3,4,5,6}
print(a.issubset(b)) #a是不是b的子集
print(a.issuperset(b)) #a是不是b的父集
函数
def name(x,y): #name函数名字，(x,y)形参
res = x**y
return res #return：1、返回函数结果；2、代表函数的结束
c = name(a,b) #(a,b)实参
print(c)
实参：有确定值的参数，所有数据类型都可以当作参数传递给函数
形参：只有在被调用的时候才分配内存，调用后，立刻释放内存，值仅在函数内部有效（形参的作用域只在当前函数内部生效）
--------------------------------------------
def change(a):
print(a) #引用全局变量
a = "syan" #局部变量
print(a)
b = "bob" #全局变量
print(b)
change(b)
print(b)
全局变量默认不能被函数内部（局部变量）修改，只能引用
如果想在函数内部修改全局变量，需要在函数内部声明：global,但是强烈建议不这么使用
----------------------------------
def change():
print(names)
names[0] = "Mack"
names.append("lili")
info["age"] = 22
names = ["bob","tom"]
info = {"syan":"rain"}
change()
print(names,info)
结果：
[‘bob‘,‘tom‘]
[‘Mack‘,‘tom‘,‘lili‘]{‘syan‘:‘rain‘,‘age‘:22}
函数内部可以修改列表、字典、集合、实例（类）
位置参数：必须按顺序传入
默认参数：
关键参数：
默认参数和关键参数必须放在位置参数后面
非固定参数：*args = ()以位置参数的形式传人，**kwargs = {}以关键参数的形式传人
匿名函数：（labmda)
def calc(x,y):
return x**y
print(calc(10,12))
calc2 = lambda x,y:x**y
print(calc2(10,12))
匿名函数最复杂的运算就是三元运算:
def calc(x):
if x > 5:
return x*2
else:
return x-1
for i in map(calc,[1,2,3,4,5,6,7,8,9]):
print(i)
for i in map(lambda x:x*2 if x>5 else x-1,[1,2,3,4,5,6,7,8,9]):
print(i)
高阶函数：
def add(x,y,f):
return f(x) + f(y)
print(add(3,-5,abs))
abs为内置函数
函数在调用时不加（），则会调其内存地址
1、把一个函数的内存地址传给另一个函数当做参数
2、一个函数把另一个函数当做返回值返回
递归
def calc(n):
print(n)
if int(n/2)>0:
n = calc(int(n/2)) #将每层的结果赋值给n
print(n)
return n
print(calc(10))
可以得到最里层的值
特性：
必须有一个明确的结束条件
每次进入更深一层递归时，问题规模相对上一次递归都应有所减少
递归效率不高，递归层次过多会导致栈溢出
原文：http://www.cnblogs.com/super-sos/p/6366744.html