python常见问题

Python

• python 没有多态，而是鸭子类型
• 多继承，没有接口，可通过语法糖实现接口的作用
• lambda中只能有一句
• "/"表示之前的参数是必须是位置参数，”**“表示是后面的必须是关键字参数

Python多进程

Python 多线程是伪多线程

• 多线程子线程会随着主线程结束而中断，因此一般在主线程中调用thread.join()

• 线程方法

  • 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
  

Python协程

• 单线程的IO多路复用，使用了单线程中IO阻塞的那一段时间，但其实还是顺序执行，按照IO阻塞切换，因此不会出现协程安全问题
  • 可以说是异步操作
• 开销小，切换容易

GIL锁：全局解释器锁，Cython

• cpu计算时线程需要获取GIL锁，只有一个，因此多核cpu也只有一个线程可以执行，主要防止多线程垃圾回收不安全

  • GIL只保证有一个线程运行，但不保证线程何时切换，因此还有线程安全问题。

  • 程序代码现线程安全问题还是要加LOCK

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

• 执行IO操作时会释放锁，因此对于IO密集型任务，可以用多线程，计算密集型，不能发挥多核，多线程作用。

• 引用计数法+循环检测：GC

面向对象

• 类中的变量是静态变量，方法通过@staticmethod修饰，是静态，self.xxx=yy 实例变量

WWW

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)

SMTP

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

SOCKET

• # 旧版本异步通信
  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

b'xxxxx' xxxx 应该是字节数，例如ascii中的，或者是用16进制表示的汉字

b'a' == b'\x61'

b'\e4\xb8\xad' 按照utf8解码后就是‘中’

图形界面

Python3 Tkinter Qt

wxwidgets,Kivy,Fltk