python为指定版本安装库 指定python版本运行

#encoding=utf-8
#http://python.jobbole.com/85231/
#作用域
a=1
def A(a):
 　　a=2
 　　print 'A:',adef 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()#lzla=13
def a():
 　　print a
a()#没有输出,函数内部无法访问函数外部的变量class a():
 x=13print 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 na=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 timedef 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.closef=open('data.txt','r')
for i in f:
 　　print 'r1.5:',i
f.closef=open('data.txt','r')
r2=f.readline()
'''
while r2:
 print 'r2:',r2
 r2=f.readline()
'''
print 'r2',r2
f.closef=open('data.txt','r')
r3=f.readlines()
print "r3:",r3
f.close
'''
r1: fafafadgdsgsd
fafasfhbafafn
fmghkgk'mf,df;m
sdgknsdjvafoilnvaov
sdnvjsavnas;vnr1.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()