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

2022-08-26 08:55:59

本篇介绍内容

  • 作用域
  • 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的整数  线程标识符
上一篇：Windows 文件名的书写规范


下一篇：JVM菜鸟进阶高手之路三