在Python中，等号=是赋值语句，可以把任意数据类型赋值给变量，同一个变量可以反复赋值，而且可以是不同类型的变量。变量本身类型不固定的语言称之为动态语言，与之对应的是静态语言。
静态语言在定义变量时必须指定变量类型，如果赋值的时候类型不匹配，就会报错。
如果字符串本身包含'怎么办？比如我们要表示字符串 I'm OK ，这时，可以用" "括起来表示。类似的，如果字符串包含"，我们就可以用' '括起来表示：如果字符串既包含'又包含"怎么办？这个时候，就需要对字符串的某些特殊字符进行“转义”，Python字符串用\进行转义。
\\n 表示换行
\ 表示一个制表符
\\\\ 表示 \\ 字符本身
如果一个字符串包含很多需要转义的字符，对每一个字符都进行转义会很麻烦。为了避免这种情况，我们可以在字符串前面加个前缀 r，表示这是一个 raw 字符串，里面的字符就不需要转义了。如，r'\\(~_~)/ \\(~_~)/'。如果要表示多行字符串，可以用'''...'''表示
如果中文字符串在Python环境下遇到 UnicodeDecodeError，这是因为.py文件保存的格式有问题。可以在第一行添加注释# -*- coding: utf-8 -*-
print u'中文'
在Python中，布尔类型还可以与其他数据类型做 and、or和not运算
直接用 [ ] 把list的所有元素都括起来，就是一个list对象。通常，我们会把list赋值给一个变量，这样，就可以通过变量来引用list
索引从 0 开始，也就是说，第一个元素的索引是0，第二个元素的索引是1，以此类推。
因此，要打印第一名同学的名字，用 L[0]
添加 list 的 append() 方法或者insert()方法
定位删除L.pop()
对list中的某一个索引赋值，就可以直接用新的元素替换掉原来的元素，list包含的元素个数保持不变。
缩进请严格按照Python的习惯写法：4个空格，不要使用Tab，更不要混合Tab和空格，否则很容易造成因为缩进引起的语法错误。if age >= 18:
要避免嵌套结构的 if ... else ...，我们可以用 if ... 多个elif ... else ...的结构，一次写完所有的规则
奇数加和 for a in L:
sum+=a
x += 2
偶数不要if x%2==0:
Continue
dict的第一个特点是查找速度快，无论dict有10个元素还是10万个元素，查找速度都一样。而list的查找速度随着元素增加而逐渐下降。d={}
d.get(x)可以取到d{}中key后面的value
个数 len(s)
s = set([('Adam', 95), ('Lisa', 85), ('Bart', 59)])
for name,score in s:
print name,':',score
s.remove():s.add()
比较函数cmp(x,y)
如果想让一个函数能接受任意个参数，我们就可以定义一个可变参数：
def fn(*args):
print args
可变参数的名字前面有个 * 号，我们可以传入0个、1个或多个参数给可变参数
r.append(L[i]) 向r添加
对这种经常取指定索引范围的操作，用循环十分繁琐，因此，Python提供了切片（Slice）操作符，能大大简化这种操作。
对应上面的问题，取前3个元素，用一行代码就可以完成切片：
>>> L[0:3]
['Adam', 'Lisa', 'Bart']
只用一个 : ，表示从头到尾：
>>> L[:]
切片操作还可以指定第三个参数：
>>> L[::2]
['Adam', 'Bart']
第三个参数表示每N个取一个，上面的 L[::2] 会每两个元素取出一个来，也就是隔一个取一个。
print L[4::5][-10:] 先获得5的倍数，再取后10个
首字母大写 def firstCharUpper(s):
return s[:1].upper()+s[1:]
range(1,101)
方法是使用 enumerate() 函数：
>>> L = ['Adam', 'Lisa', 'Bart', 'Paul']
>>> for index, name in enumerate(L):
... print index, '-', name
...
0 - Adam
1 - Lisa
2 - Bart
3 - Paul
dict 对象有一个 values() 方法，这个方法把dict转换成一个包含所有value的list，这样，我们迭代的就是 dict的每一个 value：
d = { 'Adam': 95, 'Lisa': 85, 'Bart': 59 }
print d.values()
# [85, 95, 59]
for v in d.(iter)values():
print v
# 85
# 95
# 59
items() 方法把dict对象转换成了包含tuple的list，我们对这个list进行迭代，可以同时获得key和value
d = { 'Adam': 95, 'Lisa': 85, 'Bart': 59, 'Paul': 74 }
n=0
sum = 0.0
for k, v in d.iteritems():
sum = sum + v
n+=1
print k,':',v
print 'average', ':', sum/n
[x * x for x in range(1, 11)]
变量可以指向函数 f=abs
根号 import math
def add(x, y, f):
return f(x) + f(y)
print add(25, 9, math.sqrt)
map()是 Python 内置的高阶函数，它接收一个函数 f 和一个 list，并通过把函数 f 依次作用在 list 的每个元素上，得到一个新的 list 并返回。
def format_name(s):
return s[:1].upper()+s[1:].lower()
print map(format_name, ['adam', 'LISA', 'barT'])
reduce()函数也是Python内置的一个高阶函数。reduce()函数接收的参数和 map()类似，一个函数 f，一个list，但行为和 map()不同，reduce()传入的函数 f 必须接收两个参数，reduce()对list的每个元素反复调用函数f，并返回最终结果值。reduce()还可以接收第3个可选参数，作为计算的初始值。如果把初始值设为100，计算：
reduce(f, [1, 3, 5, 7, 9], 100)
结果将变为125，因为第一轮计算是：
计算初始值和第一个元素：f(100, 1)，结果为101。
filter()函数是 Python 内置的另一个有用的高阶函数，filter()函数接收一个函数 f 和一个list，这个函数 f 的作用是对每个元素进行判断，返回 True或 False，filter()根据判断结果自动过滤掉不符合条件的元素，返回由符合条件元素组成的新list。
利用filter()，可以完成很多有用的功能，例如，删除 None 或者空字符串：
def is_not_empty(s):
return s and len(s.strip()) > 0
filter(is_not_empty, ['test', None, '', 'str', ' ', 'END'])
根为整数def is_sqr(x):
return math.sqrt(x)%1==0
升序 def cmp_ignore_case(s1, s2):
if s1.lower()>s2.lower():
return 1
elif s1.lower() else: return 0 print sorted(['bob', 'about', 'Zoo', 'Credit'], cmp_ignore_case) 像这种内层函数引用了外层函数的变量（参数也算变量），然后返回内层函数的情况，称为闭包（Closure）。 返回闭包不能引用循环变量，请改写count()函数，让它正确返回能计算1x1、2x2、3x3的函数。 def count(): fs = [] for i in range(1, 4): def f(i): def g(): return i*i return g fs.append(f(i)) return fs f1, f2, f3 = count() print f1(), f2(), f3() 通过对比可以看出，匿名函数 lambda x: x * x 实际上就是： def f(x): return x * x 关键字lambda 表示匿名函数，冒号前面的 x 表示函数参数。 测试空字符 print filter(lambda s:s and len(s.strip()) > 0, ['test', None, '', 'str', ' ', 'END']) 装饰器@new—fn def performance(f): def print_time(*args, **kw): print 'call '+f.__name__+'() in '+time.strftime('%Y-%m-%d',time.localtime(time.time())) return f(*args,**kw) return print_time 装饰器有decorator的情况下，再打印函数名： def log(f): def wrapper(*args, **kw): print 'call...' return f(*args, **kw) return wrapper @log def f2(x): pass print f2.__name__ def performance(unit): def fn(f): @functools.wraps(f) def wrapper(*args, **kw): t0 = time.time() back = f(*args, **kw) t1 = time.time() t = (t1 - t0) if unit =='s' else (t1 - t0) * 1000 print 'call %s() in %s %s' % (f.__name__, t, unit) return back return wrapper return fn int()函数还提供额外的base参数，默认值为10。如果传入base参数，就可以做 N 进制的转换： >>> int('12345', base=8) 5349 >>> int('12345', 16) 74565 假设要转换大量的二进制字符串，每次都传入int(x, base=2)非常麻烦，于是，我们想到，可以定义一个int2()的函数，默认把base=2传进去： def int2(x, base=2): return int(x, base) functools.partial就是帮助我们创建一个偏函数的，不需要我们自己定义int2()，可以直接使用下面的代码创建一个新的函数int2： >>> import functools >>> int2 = functools.partial(int, base=2) import functools sorted_ignore_case = functools.partial(sorted, cmp=lambda a,b: cmp(a.lower(),b.lower())) print sorted_ignore_case(['bob', 'about', 'Zoo', 'Credit']) math.pow(2, 0.5) from math import log 利用ImportError错误，我们经常在Python中动态导入模块： try: from cStringIO import StringIO except ImportError: from StringIO import StringIO Python 3.x已经改进了整数的除法运算，“/”除将得到浮点数，“//”除才仍是整数： >>> 10 / 3 3.3333333333333335 >>> 10 // 3 3 要在Python 2.7中引入3.x的除法规则，导入__future__的division： >>> from __future__ import division >>> print 10 / 3 3.3333333333333335 class A(object) pass a1 = A() a2 = A() 1.判断某个对象是否是类的实例 isinstance(a1, A) 2.判断两个对象是否是否完全一致（意思为： 判断两个变量引用的地址是否相同，如果相同，则两个变量实际引用为同一对象） 用is进行判断 a3 = a1 print a1 is a3 3.判断两个对象中的内容是否相同 用 == 进行判断 print a1 == a2 按照关键词排序 L1 = [p1, p2, p3] L2 = sorted(L1,key=lambda x:x.name) 在定义 Person 类时，可以为Person类添加一个特殊的__init__()方法，当创建实例时，__init__()方法被自动调用，我们就能在此为每个实例都统一加上以下属性： class Person(object): def __init__(self, name, gender, birth): self.name = name self.gender = gender self.birth = birth __init__() 方法的第一个参数必须是 self（也可以用别的名字，但建议使用习惯用法），后续参数则可以自由指定，和定义函数没有任何区别。 解释器内部会将**kw拆分成对应的dict. setattr()方法接受3个参数：setattr(对象，属性，属性的值) setattr(self,k,v)相当于self.k = v kw.iteritems()历遍字典kw的所有key和value，分别匹配k，v *args 容纳任意变量的list *kwargs 容纳任意key，value的dict class Person(object): def __init__(self, name, gender, birth, **kw): self.name=name self.gender=gender self.birth=birth for k,v in kw.iteritems(): setattr(self,k,v) Python对属性权限的控制是通过属性名来实现的，如果一个属性由双下划线开头(__)，该属性就无法被外部访问。看例子： class Person(object): def __init__(self, name): self.name = name self._title = 'Mr' self.__job = 'Student' class Person(object): def __init__(self, name, score): self.name=name self.__score=score p = Person('Bob', 59) print p.name try: print p.__score except AttributeError: print 'attributeerror' class Person(object): count=0 def __init__(self,name): self.name=name Person.count+=1 p1 = Person('Bob') print Person.count p2 = Person('Alice') print Person.count p3 = Person('Tim') print Person.count 如果已经定义了Person类，需要定义新的Student和Teacher类时，可以直接从Person类继承： class Person(object): def __init__(self, name, gender): self.name = name self.gender = gender 定义Student类时，只需要把额外的属性加上，例如score： class Student(Person): def __init__(self, name, gender, score): super(Student, self).__init__(name, gender) self.score = score 一定要用 super(Student, self).__init__(name, gender) 去初始化父类，否则，继承自 Person 的 Student 将没有 name 和 gender。 函数super(Student, self)将返回当前类继承的父类，即 Person ，然后调用__init__()方法，注意self参数已在super()中传入，在__init__()中将隐式传递，不需要写出（也不能写）。 多重继承的继承链就不是一棵树了，它像这样： class A(object): def __init__(self, a): print 'init A...' self.a = a class B(A): def __init__(self, a): super(B, self).__init__(a) print 'init B...' class C(A): def __init__(self, a): super(C, self).__init__(a) print 'init C...' class D(B, C): def __init__(self, a): super(D, self).__init__(a) print 'init D...' Python的网络服务器有TCPServer、UDPServer、UnixStreamServer、UnixDatagramServer，而服务器运行模式有 多进程ForkingMixin 和 多线程ThreadingMixin两种。 要创建多进程模式的 TCPServer： class MyTCPServer(TCPServer, ForkingMixin) pass 要创建多线程模式的 UDPServer： class MyUDPServer(UDPServer, ThreadingMixin): pass 多重 class BStudent(Student,BasketballMixin): Pass ClassC(A,B) 返回属性：对于实例变量，dir()返回所有实例属性，包括`__class__`这类有特殊意义的属性。注意到方法`whoAmI`也是 s 的一个属性。首先可以用 type() 函数获取变量的类型，它返回一个 Type 对象。dir()返回的属性是字符串列表，如果已知一个属性名称，要获取或者设置对象的属性，就需要用 getattr() 和 setattr( )函数了 对 int、str 等内置数据类型排序时，Python的 sorted() 按照默认的比较函数 cmp 排序，但是，如果对一组 Student 类的实例排序时，就必须提供我们自己的特殊方法 __cmp__()： class Student(object): def __init__(self, name, score): self.name = name self.score = score def __str__(self): return '(%s: %s)' % (self.name, self.score) __repr__ = __str__ def __cmp__(self, s): if self.name < s.name: return -1 elif self.name > s.name: return 1 else: return 0 从低到高return cmp(self.name,s.name) 从高到底 return -cmp(self.name,s.name) 如果一个类表现得像一个list，要获取有多少个元素，就得用 len() 函数。 a, b = b, a + b其实就是多个变量的赋值运算，先算=右边，再赋值给左边变量： 0)a=0,b=1 1)a=b=1,b=a+b=1 2)a=b=1,b=a+b=2 3)a=b=2,b=a+b=3 4)a=b=3,b=a+b=5 5)a=b=5,b=a+b=8 6)a=b=8,b=a+b=13 要表示有理数，可以用一个Rational类来表示： class Rational(object): def __init__(self, p, q): self.p = p self.q = q 求最大公约数 def gcs(a,b,c=1): if 0==a%2 and 0==b%2: return gcs(a/2,b/2,c*2); s = abs(a-b) m = min(a,b) if s == m: return m*c return gcs(s,m,c) 如果要把 Rational 转为 int，应该使用： r = Rational(12, 5) n = int(r) 要让int()函数正常工作，只需要实现特殊方法__int__(): class Rational(object): def __init__(self, p, q): self.p = p self.q = q def __int__(self): return self.p // self.q class Rational(object): def __init__(self, p, q): self.p = p self.q = q def __int__(self): return self.p // self.q def __float__(self): return self.p*1.0/self.q print float(Rational(7, 2)) print float(Rational(1, 3)) 以单下划线开头（_foo）的代表不能直接访问的类属性，需通过类提供的接口进行访问，不能用“from xxx import *”而导入；以双下划线开头的（__foo）代表类的私有成员；以双下划线开头和结尾的（__foo__）代表python里特殊方法专用的标识，如 __init__（）代表类的构造函数。 因为Python支持高阶函数，在函数式编程中我们介绍了装饰器函数，可以用装饰器函数把 get/set 方法“装饰”成属性调用： class Student(object): def __init__(self, name, score): self.name = name self.__score = score @property def score(self): return self.__score @score.setter def score(self, score): if score < 0 or score > 100: raise ValueError('invalid score') self.__score = score 第一个score(self)是get方法，用@property装饰，第二个score(self, score)是set方法，用@score.setter装饰，@score.setter是前一个@property装饰后的副产品。 一个类实例也可以变成一个可调用对象，只需要实现一个特殊方法__call__()。 我们把 Person 类变成一个可调用对象： class Person(object): def __init__(self, name, gender): self.name = name self.gender = gender def __call__(self, friend): print 'My name is %s...' % self.name print 'My friend is %s...' % friend 斐波那契数列： class Fib(object): def __call__(self,num): L=[0,1] i=2 for i in range(2,num): L.append(sum(L[-2:])) return L f = Fib() print f(10) Ma.span()长度 匹配ma=re.match(r’[A-Z][a-z]’,’Aa’) ma=re.match(r’[A-Z][a-z]*’,’Aasdfghjkkl’) Info=re.findall(r’\\d+’,str1)+ sum([int(x) for x in info]) 分割 把imooc和后面分割开，一个：一个空格加| （或）下载本文
