python写几个好玩的程序_python的一些有意思的程序

#用线程池+协程的一小段程序

import asyncio

from multiprocessing.dummy import Pool

@asyncio.coroutine

def write():

with open('aa.txt','a') as f:

f.write('hello,wold\n')

@asyncio.coroutine

def hello(a,b):

yield from asyncio.sleep(5)

yield from write()#协程调用方法（函数），该方法必须是异步方法，可以有返回值

print(a,b)

return 1

def works(_):

print(_)

#loop=_[1]

#can=_[0]

try:

can=_

loop=asyncio.new_event_loop()

asyncio.set_event_loop(loop)

#loop=asyncio.get_event_loop()#不能使用这个，事件循环是系统生成的，因为是多线程，所以要自己创建、设置

if loop.run_until_complete(hello('hello',can))==1:

print('get',can)

else:

print('no get',can)

loop.close()

return 1

except Exception as e:

print(e)

if __name__=="__main__":

try:

pool=Pool(3)

l=list(range(10))

print(l,'\n')

p=pool.map_async(works,l).get()#取值是为了让主线程在这里等待

print(p)

except Exception as e:

print(e)

#finally:

#pool.close()

#pool.join()

进程池的一些运用：

#/usr/bin/python3

import multiprocessing

import time,os,sys

def F(a):

print('in F')

pool1=multiprocessing.Pool(5)

l=list(range(20))

result=pool1.map_async(AA,l)

pool1.close()

pool1.join()

print('AA',result.get())

time.sleep(5)

print('this is F,value is ',a)

return 1

def G(a):

print('in G')

time.sleep(10)

print('this is G,value is ',a)

return 2

def H(a):

print('in H')

time.sleep(20)

print('this is H,value is ',a)

return 3

def I(a):

print('in I')

time.sleep(15)

print('this is I,value is ',a)

return 4

def J(a):

print('in J')

time.sleep(30)

print('this is J,value is ',a)

return 5

def K(a):

print('in K')

time.sleep(25)

print('this is K,value is ',a)

return 6

def AA(a):

print("in AA...")

time.sleep(1)

print('this is AA',a)

return a

pool=multiprocessing.Pool(3)

if __name__=='__main__':

print('in..')

try:

l=list(range(20))

result=pool.map_async(AA,l).get()

print(result)

except Exception as e:

print(e)

finally:

pool.close()

pool.join()

'''

if __name__=='__main__':

print('in..')

try:

fun_lt=[F,G,H,I,J,K]

result_lt=[]

print(sys.argv)

for f in fun_lt:

result_lt.append(pool.apply_async(f,(sys.argv,)))

#for r in result_lt:##没有关闭时打印每次返回的结果

#print(r.get())

except Exception as e:

print(e)

finally:

pool.close()

pool.join()

for r in result_lt:#统一打印

print(r.get())

'''

网络通信方面的（epoll +socket):

#直接运行可能会出问题，因为在编写的时候删除了与数据库相关的代码

#conding='utf-8'

import psycopg2

import config

import select,socket,traceback

import sys,os,time,datetime,argparse

import base64,json,types,string,errno

from multiprocessing import pool

from multiprocessing.dummy import Pool as ThreadPool

from decimal import Decimal

#客户端连接

def newconnect_client(fileno):

try:

conn,address=serversocket.accept()

conn.setblocking(False)

epoll.register(conn.fileno(),select.EPOLLIN)

d_connect[conn.fileno()]=conn

d_request[conn.fileno()]=''

d_response[conn.fileno()]=''

except:

traceback.print_exc()

#接收客户端数据

def request_client_data(fileno):

try:

data=""

while True:

tmpdata=d_connect[fileno].recv(1024).decode()#将byte转化str

if len(tmpdata)==0:

break;

data=data+tmpdata

except:

#if socket.error[0]==11:

pass

#if socket.error.errno==errno.EAGAIN:

#pass

#print(socket.error.errno)

#print(errno.EAGAIN)

#else:

#print(e)

d_request[fileno]=d_request[fileno]+data

jquery=json.loads(d_request[fileno])

if isinstance(jquery,dict):

result=greenplumAPI([jquery,fileno])

d_response[fileno]=result

elif isinstance(jquery,list):

jquery=[[j,fileno] for j in jquery]

result=pool.map_async(greenplumAPI,jquery).get()

d_response[fileno]={'result':result}

epoll.modify(fileno,select.EPOLLOUT)

#返回客户端数据

def responce_client_data(fileno):

try:

#d_connect[fileno].sendall(bytearray(json.dumps(d_response[fileno]),encoding='utf-8'))

len_t=len(bytearray(json.dumps(d_response[fileno]),encoding='utf-8'))

len_c=0

while True:

len_c+=d_connect[fileno].send(bytearray(json.dumps(d_response[fileno]),encoding='utf-8')[len_c:])

if len_c == len_t:

break

close_client(fileno)

return 0

except:

traceback.print_exc()

close_client(fileno)

return -1

#关闭客户端及epoll

def close_client(fileno):

try:

epoll.unregister(fileno)

d_connect[fileno].close()

if fileno in d_connect.keys():

del d_connect[fileno]

if fileno in d_request.keys():

del d_request[fileno]

if fileno in d_response.keys():

del d_response[fileno]

except:

traceback.print_exc()

serversocket=socket.socket(socket.AF_INET,socket.SOCK_STREAM)

serversocket.bind((config.Gpapi_host,int(config.Gpapi_port)))

serversocket.listen(1)

serversocket.setblocking(0)

epoll=select.epoll()

epoll.register(serversocket.fileno(),select.EPOLLIN)

pool=ThreadPool(40)

d_connect={}#客户端连接数据

d_request={}#客户端发送信息

d_response={}#返回客户端信息

try:

while True:

events=epoll.poll(1)#epoll轮询

for fileno,event in events:

if fileno==serversocket.fileno():#初始化

newconnect_client(fileno)

elif event&select.EPOLLIN:#接收数据

request_client_data(fileno)

elif event&select.EPOLLOUT:#回传数据

responce_client_data(fileno)

elif event&select.EPOLLHUP:#退出

close_client(fileno)

except:

traceback.print_exc()

finally:

epoll.unregister(serversocket.fileno())

epoll.close()

pool.close()

pool.join()

serversocket.close()

知识点：

1.用with XXX as X,模式:

class Content:

def __enter__(self):#进入时调用，必须有返回

print('enter')

return self

def __exit__(self,type,value,trace):#结束时调用，参数个数一定是这几个

print('exit')

def printa(self):

print('a')

with Content() as c:

c.printa()

2.普通方法、类方法、静态方法：

普通方法 可以访问类里面的属性 可以继承 只能实例可以调用；def func(self,data)

类方法 可以访问类里面的属性 可以继承 实例和类都能调用；def func(cls,data)

静态方法 不能访问类里面的属性 不能继承 实例和类都能调用。def func(data)