python学习之路-10 网络编程之进阶

本篇介绍内容

• 作用域
• python类的多继承
• IO多路复用
• socketserver之源码剖析
• 多线程和多进程

作用域

if 1 == 1:
	name = "xxx"

print(name)

上面代码在python和javascript中没有块级作用域，是可以执行的但是在c#和java中有块级作用域，会报错变量name不存在

python的作用域链

• 由内向外找
• 找不到就报错

当程序还没执行作用域在执行之前就已经定义好了，下面的例子证明了这点

name = "aaa"

def f2():
	name = "bbb"
	def f1():
		print(name)
	f1()
f2() # 在f2执行之前f1和f2的作用域就已经被定义好了

# 输出
bbb

name = "aaa"
def f1():
	print(name)

def f2():
	name = "bbb"
	f1()
f2() # 在f2执行之前f1和f2的作用域就已经被定义好了
# 输出
aaa

name = "aaa"
def f1():
	print(name)

def f2():
	name = "bbb"
	return f1

# 在f2函数被执行之前f1和f2的作用域就已经被定义好了
ret = f2()
ret()

# 输出
aaa

li = [lambda:x for x in range(10)] 

上面的语句等同于下面的

li = []
for x in range(10):

    def f1():
        return x

    li.append(f1)
print(li[0]())

多继承

• python3

• python2.7

  • 经典类
  • 新式类 继承object

IO多路复用

select poll epoll

IO多路复用底层就是监听socket对象内部是否有变化，是否在收发消息

• select IO多路复用之监听客户端连接

  • 服务端

  import socket
  import select
  
  sk = socket.socket()
  sk.bind(("127.0.0.1", 9999,))
  sk.listen(5)
  
  while True:
      rlist, w, e = select.select([sk, ], [], [], 5)
      # 监听sk(服务器端)对象,如果sk对象发生变化,表示有客户端来连接了,此时rlist值为[sk]
      # 监听conn对象,如果conn发生变化,表示客户端有消息发送过来了,此时rlist的值为[客户端]
      print(rlist)
  
      for r in rlist:
          print(r)
          conn, address = r.accept()
          conn.sendall(bytes("hello", encoding="utf-8"))
  

  • 客户端

  import socket
  
  sk = socket.socket()
  sk.connect(("127.0.0.1", 9999,))
  
  data = sk.recv(1024)
  print(data)
  
  while True:
      input(">>")
  
  sk.close()
  

• select IO多路复用之监听客户端连接以及接收客户端发送的数据

  • 服务端

  import socket
  import select
  
  sk = socket.socket()
  sk.bind(("127.0.0.1", 9999,))
  sk.listen(5)
  
  inputs = [sk,]
  while True:
      rlist, w, e = select.select(inputs, [], [], 1)
      # 监听sk(服务器端)对象,如果sk对象发生变化,表示有客户端来连接了,此时rlist值为[sk]
      # 监听conn对象,如果conn发生变化,表示客户端有消息发送过来了,此时rlist的值为[客户端]
  
      print(len(inputs), len(rlist))
  
      for r in rlist:
          print(r)
          if r == sk:
              # 有新的客户端连接进来
              conn, address = r.accept()
              inputs.append(conn)
              conn.sendall(bytes("hello", encoding="utf-8"))
          else:
              # 有客户端给我发送数据
              recv_data = r.recv(1024)
              print(recv_data)
  
  

  • 客户端

  import socket
  
  sk = socket.socket()
  sk.connect(("127.0.0.1", 9999,))
  
  data = sk.recv(1024)
  print(data)
  
  while True:
      inp = input(">>")
      sk.sendall(bytes(inp, encoding='utf-8'))
  
  sk.close()
  
  

• select IO多路复用之读写分离

  • 服务端

  import socket
  import select
  
  sk = socket.socket()
  sk.bind(("127.0.0.1", 9999,))
  sk.listen(5)
  
  inputs = [sk,]
  outputs = []
  
  while True:
      rlist, wlist, e = select.select(inputs, outputs, [], 1)
      # 监听sk(服务器端)对象,如果sk对象发生变化,表示有客户端来连接了,此时rlist值为[sk]
      # 监听conn对象,如果conn发生变化,表示客户端有消息发送过来了,此时rlist的值为[客户端]
  
      print(len(inputs), len(rlist))
  
      for r in rlist:
          print(r)
          if r == sk:
              # 有新的客户端连接进来
              conn, address = r.accept()
              inputs.append(conn)
              conn.sendall(bytes("hello", encoding="utf-8"))
          else:
              # 有客户端给我发送数据
              try:
                  recv_data = r.recv(1024)
  
                  if not recv_data: # 某些操作系统，在socket断开的时候，会发送一个空给server，所以要判断空的情况
                      raise Exception("断开连接")
                  else:
                      outputs.append(r)
              except Exception as e:
                  inputs.remove(r)
  
      for w in wlist:
          w.sendall(bytes("response", encoding="utf-8"))
          outputs.remove(w)
  

  • 客户端

  import socket
  
  sk = socket.socket()
  sk.connect(("127.0.0.1", 9999,))
  
  data = sk.recv(1024)
  print(data)
  
  while True:
      inp = input(">>")
      sk.sendall(bytes(inp, encoding='utf-8'))
      print(sk.recv(1024))
  sk.close()
  

• select IO多路复用之读写分离 - 服务端根据客户端的输入返回对应的信息

  • 服务端

  import socket
  import select
  
  sk = socket.socket()
  sk.bind(("127.0.0.1", 9999,))
  sk.listen(5)
  
  inputs = [sk, ]  #
  outputs = []
  messages = {}   # 用来存放客户端发送过来的消息,存放格式   连接客户端的对象: 消息
  
  while True:
      rlist, wlist, elist = select.select(inputs, outputs, [sk, ], 1)
      # rlist  监听sk(服务器端)对象,如果sk对象发生变化,表示有客户端来连接了,此时rlist值为[sk]
      # wlist  监听conn对象,如果conn发生变化,表示客户端有消息发送过来了,此时rlist的值为[客户端]
      # elist  监听sk(服务器端)对象是否发生错误
  
      print(len(inputs), len(rlist))
  
      for r in rlist:
          print(r)
          if r == sk:
              # 有新的客户端连接进来
              conn, address = r.accept()
              inputs.append(conn)
              messages[conn] = []  # 在存储消息的字典中创建一个以客户端连接对象为key 空列表为value的键值对
              conn.sendall(bytes("hello", encoding="utf-8"))
          else:
              # 有客户端给我发送数据
              try:
                  recv_data = r.recv(1024)
  
                  if not recv_data: # 某些操作系统，在socket断开的时候，会发送一个空给server，所以要判断空的情况
                      raise Exception("断开连接")
                  else:
                      outputs.append(r)
                      messages[r].append(recv_data)
  
              except Exception as e:
                  inputs.remove(r)
                  del messages[r]
  
      for w in wlist:
          print(messages[w])
          msg = messages[w].pop()
          resp = msg + bytes("response", encoding="utf-8")
          w.sendall(resp)
          outputs.remove(w)
  
  

  • 客户端

  import socket
  
  sk = socket.socket()
  sk.connect(("127.0.0.1", 9999,))
  
  data = sk.recv(1024)
  print(data)
  
  while True:
      inp = input(">>")
      sk.sendall(bytes(inp, encoding='utf-8'))
      print(sk.recv(1024))
  sk.close()
  

socketserver之源码剖析

多线程和多进程

多线程和多进程的定义

• 一个应用程序，可以有多进程和多线程
• 默认：单进程，单线程
• 单进程，多线程
  • IO类型的操作，不占用CPU，使用多线程进行IO操作，提高并发
  • 计算类型的操作，需要CPU计算，使用多进程进行计算型密集的操作提高并发，可以利用上CPU多核的特性
• GIL全局解释器锁，在java和c#中是不存在GIL的，多线程也可以达到并发

多线程

• 初识多线程

  • 当没有多线程的时候只能够像下面代码中的这种方式进行工作

  import time
  
  def renwu(renwu_id):
      time.sleep(1)
      print(renwu_id)
  
  if __name__ == '__main__':
      for i in range(10):
          renwu(i)
  

  • 使用多线程进行操作

  import time
  import threading
  
  def renwu(renwu_id):
      time.sleep(1)
      print(renwu_id)
  
  if __name__ == '__main__':
      for i in range(10):
          t = threading.Thread(target=renwu, args=[i,])
          t.start()
  

• 多线程模块下面Thread类的一些方法

getName()	# 获得当前线程对象的名称
ident		# 返回一个非0的整数  线程标识符  未运行的返回值为空
is_alive()	# 返回一个布尔值，判断线程的存活状态
isDaemon()	# 返回一个布尔值，判断线程是否为后台程序
join()			# 设置子线程为阻塞模式
setDaemon(daemonic)	# 设置对象是否为后台程序，该方法需要在start方法之前，运行需要一个参数，传True或者False
setName(name)		# 设置线程的名称
start()	# 执行线程，不代表当前线程会被立即执行，什么时候执行由cpu调度决定

• 模块threading下面的一些函数

threading.active_count()	# 返回当前存活的线程数量，等于threading.enumerate()返回列表的长度
threading.current_thread()		# 返回当前主线程对象
threading.enumerate()	# 返回一个列表，该列表包括当前处于存活状态的线程对象
threading.get_ident()	# 返回一个非0的整数  线程标识符