python常见问题

import threading
t = thread.Thread()
t.start();
# 没有返回值，若需要返回值可继承该类，在类中保存计算结果，用以获取
# 或者传入全局结果参数，

import thread # threading 封装了thread

import threadpool # 三方库

# 线程池
import asyncio
async def coro(i):
    print("core start",i)
    ret = await get(i) # 此处为耗时的io等操作
    print("core end",i)
    return ret
async def get(i):
    await asyncio.sleep(5)
    return i
loop = asyncio.get_event_loop()
a = [asyncio.ensure_future(coro(i)) for i in range(10)]
loop.run_until_complete(asyncio.wait(a))
loop.close()
print([i.result() for i in a])

import concurrent.futures
with concurrent.futures.ThreadPoolExecutor() as pool:
    results = pool.map(function,args)   # 注意此处是任务提一提交完，args为参数列表的列表
    # result 线程的结果
    # 或者
    future = pool.submit(function,args)  # 每次提交一个
    future.result() # 结果

    for futures in futures: # 顺序执行
        xxxx
    for futures in concurrent.futures.as_completed(futures): # 不会按照顺序执行，那个线程先结束先执行那个
        xxxx

import threading
lock = threading.Lock()
lock.acquire()
lock.release()
# 或者
with lock:
    xxxx 

import urllib.request
if __name__ == '__main__':
    data = urllib.parse.urlencode({'wd':'python'}).encode("utf8")
    request = urllib.request.urlopen("http://baidu.com",data=data)
    with request:
        msg,hd = request.read(),request.info()
        print(msg)
        print(hd)

# smtplib email 配合使用
# 或是unix系统中的sendmail命令

# 旧版本异步通信
import asyncore
class HTTPClient(asyncore.dispatcher):
    def __init__(self,host):
        #  初始化父类
        asyncore.dispatcher.__init__(self)
        # 创建一个socket对象
        self.create_socket()
        # 连接服务器端
        self.connect((host,80))
    #发送优化
        self.buffer = b'GET /HTTP/1.1\r\nHost: www.baidu.com\r\n\r\n'
    def handle_connect(self):
        print('服务器连接成功')
    def handle_close(self):
        print('服务器连接断开')
        self.close()
    def readable(self):
        return True
    def handle_read(self):
        # 指定一次读取1024个字节，如果一次没有读完的话，那么事件循环会分多次把内容读完为止
        print(self.recv(1024).decode())
    def writable(self):
        return (len(self.buffer)>0)
    def handle_write(self):
        sent = self.send(self.buffer)
        self.buffer = self.buffer[sent:]
if __name__ == '__main__':
    HTTPClient('www.baidu.com')
    asyncore.loop()
 import asyncore
import socket

class EchoHandler(asyncore.dispatcher_with_send):
    def handle_read(self):
        data = self.recv(8192)
        if data:
            self.send("hello".encode('utf8')+data)
class EchoServer(asyncore.dispatcher):
    def __init__(self, host, port):
        asyncore.dispatcher.__init__(self)
        self.create_socket(socket.AF_INET, socket.SOCK_STREAM)
        self.set_reuse_addr()
        self.bind((host, port))
        self.listen(5)
    def handle_accept(self):
        pair = self.accept()
        if pair is not None:
            sock, addr = pair
            print('Incoming connection from %s' % repr(addr))
            handler = EchoHandler(sock)
if __name__ == '__main__':
    server = EchoServer('10.101.33.82', 8080)
    asyncore.loop()

import asyncio
async def handle_echo(reader, writer):
    while True:
        data = await reader.read(100)
        message = data.decode("gbk")
        addr = writer.get_extra_info('peername')
        print(f"Received {message!r} from {addr!r}")
        if message == '-1':
            writer.write("将会结束!".encode("gbk"))
        else:
            writer.write(message.encode("gbk"))
        await writer.drain()

        if message == '-1':
            writer.close()
            break
async def main():
    server = await asyncio.start_server(
        handle_echo, '10.101.33.82', 8080)

    addr = server.sockets[0].getsockname()
    print(f'Serving on {addr}')

    async with server:
        await server.serve_forever()

asyncio.run(main())

# 编码,utf8
#3字节 1110xxxx 10xxxxxx 10xxxxxx   中文:"中"
# utf8--> 4e2d -》0100 1110 0010 1101
b'\xe4\xb8\xad'.decode('utf8') # “中“
# 与上边组 1110 0100 10111000 10101101 -》就是 e4b8ad