#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
', 'fafasfhbafafn
', "fmghkgk'mf,df;m
", 'sdgknsdjvafoilnvaov
', 'sdnvjsavnas;vn
']
'''
#正则
import re
f=open('order.txt','r')
text=f.read()
pattern=re.compile('HK/(.*?)/')
print re.findall(pattern,text)#['NI1234567890', 'NI1234567890']
f.close()