python使用(三)

1.function_option.py
2.function_code_option.py
3.thread_option.py
4.class_option.py
5.threading_option.py
6.producer_conusmer_option.py

1.function_option.py

 # coding=utf8
 __author__ = 'SummerChill'

 #一般函数
 def my_abs(x):
     """this is a abs method"""
     if isinstance(x,int):
         if x>=0:
             return x
         else:
             return -x
 #函数调用
 print(my_abs('ss'))#None

 #空函数 类似于占位符的概念,这个函数没有写完,别人也可以调用而且调用不报错.
 def nop():
     pass

 nop()

 ####python函数可以没有返回值，如果没有则默认为None

 #多值函数
 #函数可以有多个值 多个值以元组的方式来展示的，获取后不允许修改返回值。
 def multi(x,y):
     return x,x+y

 data=multi(1,2)
 print(data)#(1, 3)

 def add(x,y,f):
     return f(x)+f(y)
 #函数可以作为变量 传入时只传入函数名称[去掉自动添加的()]

 #lambda作为一个表达式，定义了一个匿名函数，上例的代码x为入口参数，x+1为函数

 #默认的参数 注意：非默认参数不能在默认参数的后面
 #用户传入则以用户的为准，否则取默认值
 def defalut(x,y=1,z=2):
     return x+y+z

 #可变的参数 可变参数的接受端 是以tuple方式接受的
 #常规的参数不能在可变的参数的后面
 def change(x,*y):
     total=0
     for i in y:
         total=total+i
     return x,total
 print(change(1,1,2,3,4,5))#(1, 15)

 ###########调用函数时
 #对号入座
 print(multi(1,2))#(1, 3)
 print(multi(2,1))#(2, 3)
 #直接指定参数 养成好的习惯
 print(multi(y=2,x=1))#(1, 3)

2.function_code_option.py

 # coding=utf8
 __author__ = 'SummerChill'

 #lamda
 add=lambda x,y:x+y

 #apply 使用参数来触发方法并且获取返回值。一般了解就可以
 #第一个方法的名称
 #方法中的一般的参数
 #方法中的可变参数
 def addnew(x,y,**z):
     print(z,x,y)

 def addold(x,y):
     print(x,y)
 apply(addnew,[1,2],{'a':1,'b':2})#({'a': 1, 'b': 2}, 1, 2)
 apply(addold,[1,2])#(1, 2)

 #filter 过滤函数[返回布尔类型]和要过滤的seq集合
 #sequence:list,tuple,set,string,dic
 #返回值：list string tuple
 def filterfun(x):
     if int(x)%2==0:
         return True
     else:
         return False

 print(filter(filterfun,[1,2,3,4,5,6,7,8,9]))#[2, 4, 6, 8]
 print(filter(filterfun,(1,2,3,4,5,6,7,8,9)))#(2, 4, 6, 8)
 print(filter(filterfun,set([1,2,3,4,5,6,7,8,9])))#[2, 4, 6, 8]

 ':'A',2:'B',3:'C'}))#[2]

 #map 将传入的seq 进过一个mapfun函数计算得到一个新的list
 #返回值都有list
 def map_fun(x):
     return 2*int(x)

 print(map(map_fun,[1,2,3,4,5,6,7,8,9]))#[2, 4, 6, 8, 10, 12, 14, 16, 18]
 print(map(map_fun,(1,2,3,4,5,6,7,8,9)))#[2, 4, 6, 8, 10, 12, 14, 16, 18]
 print(map(map_fun,set([1,2,3,4,5,6,7,8,9])))#[2, 4, 6, 8, 10, 12, 14, 16, 18]
 '))#[2, 4, 6, 8, 10, 12, 14, 16, 18]
 ':'A',2:'B',3:'C'}))#[2, 4, 6]

 #两个参数还是map 是两个序列的聚合
 #不改变单个序列的元素个数
 #在map函数为多个参数中，两个序列分别传给对应的参数，
 # 如果有一方个数不足，则默认为None
 def map_fun_new(x,y):
     if x is None:
         x=0
     if y is None:
         y=0
     return int(x)+int(y)
 print(map(map_fun_new,(1,2,3,4),[1,2]))#[2, 4, 3, 4]

 #reduce
 def reuduce_fun(x,y):
     return x,y

 #先将序列中的前两个带入计算，然后将计算结果a和第三个元素带入计算，一次迭代
 #如果指定了initial则首先从此值和第一个元素开始计算。
 print(reduce(reuduce_fun,[1,2,3,4,5,6,7,8,9]))#((((((((1, 2), 3), 4), 5), 6), 7), 8), 9)  最终是一个大的tuple
 print(reduce(reuduce_fun,[1,2,3,4,5,6,7,8,9],10))#(((((((((10, 1), 2), 3), 4), 5), 6), 7), 8), 9)

 ##################异常的处理
 try:
     print 'try...'
     r = 10 / 0
     print 'result:', r
 except Exception as e:
     print 'except:', e #except: integer division or modulo by zero
     #raise #一旦执行了raise语句，raise后面的语句将不能执行(和Java中throw一样)  #ZeroDivisionError: integer division or modulo by zero
     #print("end raise")
 finally:
     print 'finally...'
 print 'END'

3.thread_option.py

 # coding=utf8
 __author__ = 'SummerChill'

 import thread,time
 #主线程退出则此线程会终止
 lt=thread.allocate_lock()
 def sayHi():
     print(time.ctime()+"------"+str(thread.get_ident()),"hi")
     print(time.ctime()+"------"+str(thread.get_ident()),"is locked:"+str(lt.locked()))
     print(time.ctime()+"------"+str(thread.get_ident()),"begin get lock")
     #尝试着去获取锁 参数为watiFlag True表示如果此锁被其他人占用则等待
     #如果为False则不等待，如果有其他线程占用 获取失败
     lt.acquire(True)
     time.sleep(5)
     print(time.ctime()+"------"+str(thread.get_ident()),"end get lock")
     print(time.ctime()+"------"+str(thread.get_ident()),"begin release lock")
     #释放锁
     lt.release()
     print(time.ctime()+"------"+str(thread.get_ident()),"end release lock")
     # thread.interrupt_main()
 thread.start_new_thread(sayHi,())
 time.sleep(2)
 thread.start_new_thread(sayHi,())

 #10s后main线程自动关闭
 try:
     time.sleep(10)
 except KeyboardInterrupt:
     print('我被打断了')
 finally:
     print('done')
 """
 ('Thu Sep 22 08:48:57 2016------11432', 'hi')
 ('Thu Sep 22 08:48:57 2016------11432', 'is locked:False')
 ('Thu Sep 22 08:48:57 2016------11432', 'begin get lock')
 ('Thu Sep 22 08:48:59 2016------10712', 'hi')
 ('Thu Sep 22 08:48:59 2016------10712', 'is locked:True')
 ('Thu Sep 22 08:48:59 2016------10712', 'begin get lock')
 ('Thu Sep 22 08:49:02 2016------11432', 'end get lock')
 ('Thu Sep 22 08:49:02 2016------11432', 'begin release lock')
 ('Thu Sep 22 08:49:02 2016------11432', 'end release lock')
 ('Thu Sep 22 08:49:07 2016------10712', 'end get lock')
 ('Thu Sep 22 08:49:07 2016------10712', 'begin release lock')
 ('Thu Sep 22 08:49:07 2016------10712', 'end release lock')
 done
 """

4.class_option.py

 # coding=utf8
 __author__ = 'SummerChill'

 """
 定义的关键字：class。
     一个类里的初始化方法__init__(self，？)，第一个参数必须是self。
     这是构造方法。内部的方法第一个参数也要是self，self相当于java对象里的this。

 注：
 一个类里只识别一个__init__(self，？)方法。
 如果有多个则后者覆盖前者。
 即：如果一个类中有名字重复的函数。
 不论参数个数是否一致只识别最后一个。。
 """
 class Person:
     name=''
     def __init__(self):
         pass
     def __init__(self,_name):
         print('ss')

     def say(self):
         print("Person%s"%(self.name))
     def say(self,id):
         print("Person%s %s "%(self.name,id))
 p=Person('zenith')
 p.say(1)
 #python 里没有方法重载问题 后者覆盖前者

 class Man(Person):
     id=''
     def __init__(self,_id,_name):
         self.id=_id
         self.name=_name
     def say(self):
         print("Man %s %s "%(self.name,self.id))

 m=Man(1,'man')
 m.say()
 #如果一个成员变量或者方法，父类有子类也有则子类覆盖父类的成员变量或者方法。

5.threading_option.py

 # coding=utf8
 __author__ = 'SummerChill'
 import threading,time

 class Worker(threading.Thread):
     def __init__(self):
         # 如果自定义了构造函数则要将threading.Thread初始化。
         #AssertionError: Thread.__init__() not called
         threading.Thread.__init__(self)

     def run(self):
         print(self.getName())
         print('begin hi')
         time.sleep(5)
         print('end hi')
         print(self.isAlive())
         #是否为守护线程
         print(self.isDaemon())

 print('main begin')
 th=Worker()
 th.setName('th_hi')
 #守护线程：如果用户线程都死亡了，此线程亦会终止,和main主进程没有任何关系.
 th.setDaemon(False)
 th.start()
 #join 不加参数会等当前线程在等待join的线程结束后再继续,timeout 参数最多等n秒
 th.join()
 print('main end')

6.producer_conusmer_option.py

 # coding=utf8
 __author__ = 'SummerChill'

 import threading,Queue,time,random

 #练习：一个线程每0.5s随机生产一个0-10的数字，另一线程5s统计一次结果。
 #生产者
 class DataProducer(threading.Thread):
     q=None
     def __init__(self,_queue):
         threading.Thread.__init__(self)
         self.q=_queue
     def run(self):
         while True:
             time.sleep(0.5)
             self.q.put(random.randint(0,10),True)

 #消费者
 class DataConsumer(threading.Thread):
     q=None
     def __init__(self,_queue):
         threading.Thread.__init__(self)
         self.q=_queue
     def run(self):
         while True:
             time.sleep(5)
             sum=0
             while not self.q.empty():
                 #不会空肯定能够get到数据 不用阻塞也不会报empty错
                 sum=sum+self.q.get(False)
             print("sum:"+str(sum))

 que=Queue.Queue()
 dp=DataProducer(que)
 dp.start()

 dc=DataConsumer(que)
 dc.start()