感觉总结了一切python常见知识点，可直接运行版本

#encoding=utf-8
#http://python.jobbole.com/85231/
#作用域
a=1
def A(a):
　　a=2
　　print 'A:',a

def B():
　　print 'B:',a
A(a)
print '外部：',a
B()
#函数内的赋值无法改变函数外的值
'''
A: 2
外部： 1
B: 1
'''
#局部作用域

def func():
　　name = "lzl"

#print(name)#name 'name' is not defined
#函数内赋值无法在函数外生效

#块级作用域

if 1 == 1:
　　name = "lzl"

print(name)#lzl
#模块内的赋值可以被模块外访问

#作用域链

name = "lzl"
def f1():
　　name = "Eric"
　　def f2():
　　　　name = "Snor"

print(name)
f2()
f1()#Snor
#优先读取内部函数

#终极版作用域

name = "lzl"

def f1():
　　print(name)

def f2():
　　name = "eric"
f1()#相当于return f1

f2()#lzl

a=13
def a():
　　print a
a()#没有输出,函数内部无法访问函数外部的变量

class a():
x=13

print x#name 'x' is not defined
#不能直接访问一个类的内部函数或变量，但是可以通过先构造类，再去访问
#比如：a()之后在print x就可以有结果了
class a():
　　def bb(self):
　　　　x=13
　　　　x+=1
　　　　return x#name

#bb()#name 'bb' is not defined
aa=a()
print aa.bb()#14

#函数也一样不能直接调用，可以a.函数名来调用

#各种方法类型
class A(object):
　　def m1(self,n):
　　　　print 'self:',self
　　@classmethod#如果没加类方法，结果与m1相同
　　　def m2(cls,n):
　　　　　print 'cls:',cls
　　@staticmethod#未加静态方法，则报错
　　def m3(n):
　　　　print n

a=A()
a.m1(1)#self: <__main__.A object at 0x00000000023E54A8>
#A.m1(1) #报unbound method m1()，不可以绑定类
a.m2(1)#cls: <class '__main__.A'>
A.m2(1)#cls: <class '__main__.A'>
#均指向类
a.m3(1)#1
A.m3(1)#1
#静态函数跟普通函数没什么区别，与类和实例都没有所谓的绑定关系，它只不过是碰巧存在类中的一个函数而已

#类变量，实例变量
class A():
para='aaa'
a=A()
b=A()
b.para='bbb'
print a.para#aaa
print b.para#bbb
print A.para#aaa
#首先class内的方法和变量都是可以被直接访问的，其次实例变量会覆盖类变量，但类仅覆盖此实例

#各种下划线命名
'''
__foo__:一种约定,Python内部的名字,用来区别其他用户自定义的命名,以防冲突.

_foo:一种约定,用来指定变量私有.程序员用来指定私有变量的一种方式.

__foo:这个有真正的意义:解析器用_classname__foo来代替这个名字,以区别和其他类相同的命名.
'''
class C():
　　def __init__(self):
　　　　self.__para='aaa'#private
　　　　self._para='bbb'#无法import到其它模块
c=C()
#print c.__para #C instance has no attribute '__para'
print c._para#bbb
#根据python的约定，应该将其视作private，而不要在外部使用它们（如果你非要使用也没辙）
print c._C__para#aaa
#"单下划线" 开始的成员变量叫做保护变量，意思是只有类对象和子类对象自己能访问到这些变量；
#"双下划线" 开始的是私有成员，意思是只有类对象自己能访问，连子类对象也不能访问到这个数据
#格式化
name='GarVicker'
profession='painter'
old=122
print "My name is %s,I'm a %s,%d years old"%(name,profession,old)
#My name is GarVicker,I'm a painter,122 years old

#非确定个数参数

def fun(a,b,c):
　　print a,b,c
l=[1,2,3]
#fun(l)#fun() takes exactly 3 arguments (1 given)
fun(*l)#1 2 3
l=[1,2]#fun(*l)#fun() takes exactly 3 arguments (2 given)
#*用来逐个添加l内的各个参数
def fun2(*args):#args输出元组
　　print args
fun2(*l)#(1, 2)
fun2(l)#([1, 2],)

def fun3(n,**kwargs):#args输出元组
　　print n,kwargs
m={a:3,b:4,c:5}
n={'a':3,'b':4,'c':5}

fun3(m)
#{<__main__.A instance at 0x00000000028C6E08>: 4, <__main__.C instance at 0x00000000028C6E48>: 5, <__main__.A instance at 0x00000000028C6DC8>: 3} {}
#把a,b,c当成class输出了
fun3(n)#{'a': 3, 'c': 5, 'b': 4} {}
fun3(3,b=4,c=5)#3 {'c': 5, 'b': 4}
#常规参数列表中只有一个变量’a’.但是通过”**kwargs”,可以传多个键值参数
fun3(1, **{'b':2, 'c':34})#1 {'c': 34, 'b': 2}

#闭包
'''
1、把局部变量 x 作为参数了传递进来
2、嵌套函数不再直接在函数里被调用，而是作为返回值返回
3、这里的 closure就是一个闭包
'''
def outer(func):

　　def inner():

　　　　print("记录日志开始")

　　　　func() # 业务函数

　　　　print("记录日志结束")

　　return inner
#装饰器
@outer
def foo():

　　print("装饰器foo")

foo()
'''
记录日志开始
装饰器foo
记录日志结束
'''
#等同于
def foo():

　　print("不用装饰器的foo")

foo1 = outer(foo)

foo1()
'''
记录日志开始
不用装饰器的foo
记录日志结束
'''

#单例模式：该模式的主要目的是确保某一个类只有一个实例存在
#使用模块方法
#mysingleton.py
class Singleton(object):
　　def foo(self):
　　　　pass
singleton = Singleton()
#使用时from mysingleton import singleton，singleton。foo()

#协程
import time

def consumer():
　　r = ''
　　while True:
　　　　n = yield r
　　　　if not n:
　　　　　　return
　　　　print('[CONSUMER] Consuming %s...' % n)
　　　　time.sleep(1)
　　　　r = '200 OK'

def produce(c):
　　c.next()
　　n = 0
　　while n < 2:
　　　　n = n + 1
　　　　print('[PRODUCER] Producing %s...' % n)
　　　　r = c.send(n)
　　　　print('[PRODUCER] Consumer return: %s' % r)
　　c.close()

c = consumer()
#produce(c)
'''
[PRODUCER] Producing 1...
[CONSUMER] Consuming 1...
[PRODUCER] Consumer return: 200 OK
[PRODUCER] Producing 2...
[CONSUMER] Consuming 2...
[PRODUCER] Consumer return: 200 OK
'''

#函数式
#lambda 传入参数:方法并输出
a = map(lambda x:x*2,[1,2,3])#[2, 4, 6]
print a
a = [1,2,3,4,5,6,7]
b = filter(lambda x: x > 5, a)
print b#[6, 7]

#深浅拷贝
import copy
a = [1, 2, 3, 4, ['a', 'b']] #原始对象
e=a[:]#切片，相当于浅拷贝
b = a #赋值，传对象的引用
c = copy.copy(a) #对象拷贝，浅拷贝
d = copy.deepcopy(a) #对象拷贝，深拷贝

a.append(5) #修改对象a
a[4].append('c') #修改对象a中的['a', 'b']数组对象

print 'a = ', a
print 'b = ', b
print 'c = ', c
print 'd = ', d
print 'e = ', e
'''
copy会对原对象拷贝，但不会递归深拷贝，而deepcopy是递归深拷贝的，这么一来copy是介于=和deepcopy的，用的肯定不多。
1. copy.copy 浅拷贝 只拷贝父对象，不会拷贝对象的内部的子对象。
2. copy.deepcopy 深拷贝 拷贝对象及其子对象
a = [1, 2, 3, 4, ['a', 'b', 'c'], 5]
b = [1, 2, 3, 4, ['a', 'b', 'c'], 5]
c = [1, 2, 3, 4, ['a', 'b', 'c']]
d = [1, 2, 3, 4, ['a', 'b']]
e = [1, 2, 3, 4, ['a', 'b', 'c']]
'''

#is是对比地址,==是对比值

#read，readlin，readlines
f=open('data.txt','r')
r1=f.read()
print 'r1:',r1
f.close

f=open('data.txt','r')
for i in f:
　　print 'r1.5:',i
f.close

f=open('data.txt','r')
r2=f.readline()
'''
while r2:
print 'r2:',r2
r2=f.readline()
'''
print 'r2',r2
f.close

f=open('data.txt','r')
r3=f.readlines()
print "r3:",r3
f.close
'''
r1: fafafadgdsgsd
fafasfhbafafn
fmghkgk'mf,df;m
sdgknsdjvafoilnvaov
sdnvjsavnas;vn

r1.5: fafafadgdsgsd

r1.5: fafasfhbafafn

r1.5: fmghkgk'mf,df;m

r1.5: sdgknsdjvafoilnvaov

r1.5: sdnvjsavnas;vn

r2 fafafadgdsgsd

r3: ['fafafadgdsgsd\n', 'fafasfhbafafn\n', "fmghkgk'mf,df;m\n", 'sdgknsdjvafoilnvaov\n', 'sdnvjsavnas;vn\n']
'''

#正则
import re
f=open('order.txt','r')
text=f.read()
pattern=re.compile('HK/(.*?)/')
print re.findall(pattern,text)#['NI1234567890', 'NI1234567890']
f.close()