封装，多态，反射，异常处理，网络编程

Posted 2020-10-03

接口与归一化设计（python中使用继承的方式）

抽象类

import abc
class Interface(metaclass=abc.ABCMeta): #定义接口Interface类来模仿接口的概念，python中
#没有interface关键字来定义一个接口
all_type=‘file‘
#只定义功能集合而不实现具体的功能
@abc.abcstractmethod
def read(self): # 定义接口函数read
pass
@abc.abcstractmethod
def write(self): # 定义接口函数write
pass

class Txt(Interface): #文本，具体实现read和write 
def read(self):
print(‘文本数据的读取方法‘)
def write(self):
print(‘文本数据的写方法‘)

t=Txt()
print(t.all_type)

多态

一种接口，多种实现(接口重用)

class Animal:
def __init__(self,name):
self.name=name

def talk(self):
pass

@staticmethod
def animal_talk(obj):
obj.talk()

class Cat(Animal):
def talk(self):
print(‘Meow!‘)

class Dog(Animal):
def talk(self):
print(‘Woof!Woof!‘)

d = Dog(‘chen‘)
#d.talk()

c = Cat(‘xu‘)
#c.talk()

使用统一的接口
Animal.animal_talk(c)
Animal.animal_talk(d)

封装

1.如何隐藏属性（类的属性和对象的属性）

class Foo:
__N=1111 # 类的属性被隐藏 _Foo__N:1111
def __init__(self,name):
self.__Name=name # 给对象属性隐藏 self._Foo__Name=name

def __f1(self): #_Foo__f1
print(‘f1‘)

def f2(self):
self.__f1() # self._Foo__f1()

f=Foo(‘egon‘)
#print(f.__N) # 报错，无法访问
#f.__f1() # 也无法访问
#f.__Name #也无法访问
f.f2() # f1 内部调用，可以访问

#以上隐藏需要注意的问题：

#1.这种隐藏只是一种语法上变形操作，并不会将属性真正隐藏起来
#print(Foo.__dict__)类的名称空间 => ‘-Foo__N‘:1111
#print(f.__dict__)对象的名称空间 => {‘_foo_Name‘:‘egon‘}
#print(f._foo_Name) # egon
#print(f._Foo__N) # 1111

#2.这种语法级别的变形是在类定义阶段发生，并且只在类定义阶段发生
Foo.__x=2222
print(Foo.__dict__) # ‘__x‘:2222
print(Foo.__x) # 2222
f.__x=3333
print(f.__dict__) # ‘__x‘:3333 并没有发生变形
print(f.__x) # 3333

#3.在子类定义的__x不会覆盖在父类定义的__x,因为子类中变形成了：_子类名__x，
#而父类中变形成了：_父类名__x,即双下划线开头的属性在继承给子类时，子类是无法覆盖的

class Foo:
__N=1111 # _Foo__N
def __init__(self,name):
self.__Name=name # self._Foo__name=name

def __f1(self): # _Foo__f1
print(‘f1‘)

def f2(self):
self.__f1() # self._Foo__f1()


f=Foo(‘egon‘)
#print(f.__N)
#f.__f1()
#f.__Name
#f.f2()

封装的真实目的

#封装不是单纯意义上的隐藏
#1.封装数据属性:将属性隐藏起来，然后对外提供访问属性的接口，关键是我们在接口内定制一些控制逻辑
#从而严格控制使用对数据属性的使用

class People:
def __init__(self,name,age):
self.__Name=name
self.__Age=age

def tell_info(self):
print(‘<名字:%s 年龄:%s>‘ % (self.__Name,self.__Age))

def set_info(self,x,y):
if not isinstance(x,str):
raise TypeError(‘%s must be str‘ %x)
if not isinstance(y,int):
raise TypeError(‘%s must be int‘ %y)
self.__Name=x
self.__Age=y

p=People(‘egon‘,18)
p.tell_info()

#p.set_info(‘Egon‘,‘19‘)
p.set_info(‘Egon‘,19)
p.tell_info()

#2.封装函数属性：为了隔离复杂度

class ATM:
def __card(self):
print(‘插卡‘)
def __auth(self):
print(‘用户认证‘)
def __input(self):
print(‘输入取款金额‘)
def __print_bill(self):
print(‘打印账单‘)
def __take_money(self):
print(‘取款‘)

def withdraw(self):
self.__card()
self.__auth()
self.__input()
self.__print_bill()
self.__take_money()

a=ATM()
a.withdraw()

静态属性property

# bmi 体脂指数
class People:
def __init__(self,name,weight,height):
self.name=name
self.weight=weight
self.height=height

@property
def bmi(self):
return self.weight / (self.height**2)

p=People(‘egon‘,75,1.80)
#print(p.bmi())
#bmi是一个名词,像访问数据属性一样访问bmi就可以了
print(p.bmi)

#访问，设置，删除
class Foo:
def __init__(self,x):
self.__Name=x

@property
def name(self):
return self.__Name

@name.setter # 前提是name已经被property修饰过一次了，才能调用.setter
def name(self,val):
if not isinstance(val,str):
raise TypeError
self.__Name=val

@name.deleter
def name(self):
#print(‘===‘)
#del self.__Name
raise PermissionError # 不允许删除

f=Foo(‘egon‘)
print(f.name)
f.name=‘Egon‘
print(f.name)
del f.name
print(f.name)

反射

#通过字符串找到属性对应的值

class Foo:
x=1
def __init__(self,name):
self.name=name

def f1(self):
print(‘from f1‘)

f=Foo(‘egon‘)

#hasattr
print(hasattr(f,‘name‘)) # f.name
print(hasattr(f,‘f1‘)) # f.f1
print(hasattr(f,‘x‘)) # f.x

#setattr
setattr(f,‘age‘,18) # f.age=18

#getattr
print(getattr(f,‘name‘)) # f.name
print(getattr(f,‘abc‘,None)) # f.abc
print(getattr(f,‘name‘,None)) # f.abc

func=getattr(f,‘f1‘) # f.f1
print(func)
func()

#delattr
delattr(f,‘name‘) # del f.name
print(f.__dict__)

class FtpServer:

def __init__(self,host,port):
self.host=host
self.port=port

def run(self):
while True:
cmd=input(‘>>: ‘).strip()
if not cmd:continue
if hasattr(self,cmd):
func=getattr(self,cmd)
func()
def get(self):
print(‘get func‘)

def put(self):
print(‘put func‘)

f=FtpServer(‘192.168.1.2‘,21)
f.run()

----------------------------------------------
item系列
#把对象变成类似字典对象，可以像字典一样进行增删改查
#也是一种归一化的思想

#__setitem__,__getitem__,__delitem__

class Foo:
def __getitem__(self,item):
print(‘getitem--->‘,self,item)
return self.__dict__[item]

def __setitem__(self,key,value):
print(‘setitem--->‘,self,key,value)
self.__dict__[key]=value
# setattr(self,key,value) 效果一样

def __delitem__(self,key):
print(‘delitem--->‘,self,key)
self.__dict__.pop(key)

f=Foo()
f[‘x‘]=1111
del f[‘x‘]
print(f[‘x‘])
----------------------------------------------

 

打印对象信息__str__

class People:
def __init__(self,name,age,sex):
self.name=name
self.age=age
self.sex=sex

def __str__(self): #在对象被打印时触发执行
return ‘<name:%s age:%s sex:%s>‘ % (self.name,self.age,self.sex) #只能返回字符串类型

p=People(‘egon‘,18,‘male‘)

print(p)

----------------------------------------------

 

析构方法__del__
class Foo:
def __init__(self,x):
self.x=x

def __del__(self): # 在对象资源被释放时出发
print(‘---del---‘)

f=Foo()
print(‘===>‘)
----------------------------------------------

 

异常处理
#什么时候用try...except
#错误一定会发生，但是无法预知错误发生条件
#CS结构的软件能够用到，客户的操作无法控制，客户单方面把软件终止掉，
#因为服务端客户端都是基于TCP链接的，但客户端单方面把链接断开，服务端也会受影响
#这种错误有可能发生，服务端不能受影响，这就用到了异常处理
class EgonException(BaseException):
def __init__(self,msg):
self.msg=msg
def __str__(self):
return ‘<%s>‘ % self.msg

raise EgonException(‘egon的异常‘)

 

----------------------------------------------

基于tcp协议的socket实现简单通信

简单的套接字

1.服务端

# socket.AF_INET 用什么类型的套接字,地址家族
# socket.SOCK_STREAM 流式套接字,就是调用tcp

import socket
#买手机
phone=socket.socket(socket.AF_INET,socket.SOCK_STREAM) # 基于tcp的套接字

#插卡
phone.bind((‘127.0.0.1‘,8080))

#开机
phone.listen(5) #最大挂起的链接数

#等电话链接
print(‘server start...‘)
conn,client_addr=phone.accept() # (建立好的tcp链接，客户端的ip和端口)
print(‘链接‘,conn)
print(client_addr)

#基于建立的链接，收发消息
client_data=conn.recv(1024)
print(‘客户端的消息‘,client_data)
conn.send(client_data.upper())

#挂电话
conn.close()

#关机
phone.close()

2.客户端
import socket

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

phone.connect((‘127.0.0.1‘,8080))

phone.send(‘hello‘.encode(‘utf-8‘)) # 需要二进制类型,转为bytes类型
server_data=phone.recv(1024) #服务端回复的消息
print(‘服务端回应的消息‘,server_data)

phone.close()

-------------------------------------------------------
加上通信循环

#服务端

import socket
phone=socket.socket(socket.AF_INET,socket.SOCK_STREAM)
phone.setsockopt(socket.SOL_SOCKET,socket.SO_REUSEADDR,1) # 用来解决Address already in use 问题

phone.bind((‘127.0.0.1‘,8080))

phone.listen(5)

print(‘server start...‘)
conn,client_addr=phone.accept()

#基于建立的链接，收发消息
while True: #通讯循环
client_data=conn.recv(1024)
conn.send(client_data.upper())

conn.close()

phone.close()

#客户端

import socket

phone=socket.socket(socket.AF_INET,socket.SOCK_STREAM)
phone.connect((‘127.0.0.1‘,8080))

while True:
msg=input(‘>>: ‘).strip()
if not msg:continue
phone.send(msg.encode(‘utf-8‘))
server_data=phone.recv(1024)
print(server_data.decode(‘utf-8‘))

phone.close()

-----------------------------------------------------
加上链接循环的套接字

#服务端

import socket
phone=socket.socket(socket.AF_INET,socket.SOCK_STREAM)
phone.setsockopt(socket.SOL_SOCKET,socket.SO_REUSEADDR,1)

phone.bind((‘127.0.0.1‘,8080))

phone.listen(5)

print(‘server start...‘)

#链接循环
while True: # 这个循环是用来解决当有Exception异常时，是客户端断了，把这个断掉的资源回收掉
# 重新等待其他链接链接进来

conn,client_addr=phone.accept()

while True:
#此处用try..except是由于和多个客户端建立了链接，一个客户端断掉链接后会服务端抛出异常，
#这样就导致其余的客户端也会发生错误，抛异常，为了使服务端能够继续和没有主动断掉链接的客户端
#继续通信，不崩溃，需要用到这个try..except..，但是只能解决不抛出异常的问题，不能解决让其他客户端
#进来和服务端建立通信
try: # 用于解决windows方面的问题
client_data=conn.recv(1024)
if not client_data:break #主要用于linux系统和mac,客户端单方面断掉后，recv不会阻塞掉，
#而是不断的收空，一直send,对方没有收，一直死循环这个try内的
#代码，所以需要加上 if not client_data:break ，如果收到的消息
#为空，肯定是客户端断掉了链接
conn.send(client_data.upper())
except Exception:
break # 把这个通信循环直接断掉

conn.close()

phone.close()

 

#客户端1

import socket

phone=socket.socket(socket.AF_INET,socket.SOCK_STREAM)
phone.connect((‘127.0.0.1‘,8080))

while True:
msg=input(‘>>: ‘).strip()
if not msg:continue
phone.send(msg.encode(‘utf-8‘))
server_data=phone.recv(1024)
print(server_data.decode(‘utf-8‘))

phone.close()

 

#客户端2

import socket

phone=socket.socket(socket.AF_INET,socket.SOCK_STREAM)
phone.connect((‘127.0.0.1‘,8080))

while True:
msg=input(‘>>: ‘).strip()
if not msg:continue
phone.send(msg.encode(‘utf-8‘))
server_data=phone.recv(1024)
print(server_data.decode(‘utf-8‘))

phone.close()

 

#客户端3

import socket

phone=socket.socket(socket.AF_INET,socket.SOCK_STREAM)
phone.connect((‘127.0.0.1‘,8080))

while True:
msg=input(‘>>: ‘).strip()
if not msg:continue
phone.send(msg.encode(‘utf-8‘))
server_data=phone.recv(1024)
print(server_data.decode(‘utf-8‘))

phone.close()

---------------------------------------------------------
模拟ssh远程执行命令

#客户端

import socket

phone=socket.socket(socket.AF_INET,socket.SOCK_STREAM)
phone.connect((‘127.0.0.1‘,8080))

while True:
cmd=input(‘>>: ‘).strip()
if not cmd:continue
#发命令
phone.send(cmd.encode(‘utf-8‘))
#收命令的执行结果
cmd_res=phone.recv(1024)
#打印结果
print(cmd_res.decode(‘gbk‘)) #linux系统的话改为utf-8

phone.close()

#服务端

import socket
import subprocess

phone=socket.socket(socket.AF_INET,socket.SOCK_STREAM)
phone.setsockopt(socket.SOL_SOCKET,socket.SO_REUSEADDR,1)
phone.bind((‘127.0.0.1‘,8080))
phone.listen(5)
print(‘server start...‘)
while True:
conn,client_addr=phone.accept()

while True:
try:
cmd=conn.recv(1024) #bytes格式
if not cmd:break
#执行命令,拿到结果(subprocess命令的执行结果是bytes类型)
res=subprocess.Popen(cmd.decode(‘utf-8‘), # 需要字符串格式，
shell=True,
stdout=subprocess.PIPE,
stderr=subprocess.PIPE)

stdout=res.stdout.read() #从正确的管道里面读，但是gbk编码
stderr=res.stderr.read() #从错误管道里面读，但是gbk编码

conn.send(stdout+stderr)
except Exception:
break
conn.close()

phone.close()

---------------------------------------------------
解决粘包问题

只有TCP有粘包现象，UDP永远不会粘包
由于TCP是流式的，没有开头没有结尾，就会发生粘包现象
UDP是数据报协议，它不是基于流的

粘包现象

服务端
from socket import *
s=socket(AF_INET,SOCK_STREAM)
s.bind((‘127.0.0.1‘,8080))
s.listen(5)

conn,addr=s.accept()

#收发消息
data1=conn.recv(1024)
print(‘data1‘,data1)

data2=conn.recv(1024)
print(‘data2‘,data2)

conn.close()
s.close()

#data1: b‘helloworld‘
#data2 b‘‘
上面的结果不一定会发生，取决于算法要不要合并到一起发送过去，
多尝试几次，就会发生

客户端
from socket import *
c=socket(AF_INET,SOCK_STREAM)
c.connect((‘127.0.0.1‘,8080))

c.send(‘hello‘.encode(‘utf-8‘))
c.send(‘world‘.encode(‘utf-8‘))

c.close()
----------------------------------------------------
ssh远程执行命令+定制报头

客户端
import socket
import struct
phone=socket.socket(socket.AF_INET,socket.SOCK_STREAM)
phone.connect((‘127.0.0.1‘,8080))

while True:
cmd=input(‘>>: ‘).strip()
if not cmd:continue
#发命令
phone.send(cmd.encode(‘utf-8‘))

#先收报头
header=phone.recv(4)
total_size=struct.unpack(‘i‘,header)[0]

#再收命令的执行结果
recv_size=0
data=b‘‘ #结果
while recv_size < total_size:
recv_data=phone.recv(1024)
recv_size+=len(recv_data)
data+=recv_data

print(data.decode(‘gbk‘))

phone.close()

 

服务端

import socket
import struct
import subprocess

phone=socket.socket(socket.AF_INET,socket.SOCK_STREAM)
phone.setsockopt(socket.SOL_SOCKET,socket.SO_REUSEADDR,1)
phone.bind((‘127.0.0.1‘,8080))
phone.listen(5)
print(‘server start...‘)
while True:
conn,client_addr=phone.accept()
print(conn,client_addr)
while True:
try:
cmd=conn.recv(1024)
if not cmd:break

res=subprocess.Popen(cmd.decode(‘utf-8‘),
shell=True,
stdout=subprocess.PIPE,
stderr=subprocess.PIPE)

stdout=res.stdout.read()
stderr=res.stderr.read()

#制作报头
header=struct.pack(‘i‘,len(stdout)+len(stderr))
#先发报头(固定长度，这里一直是4)
conn.send(header)

#再发真实数据
conn.send(stdout)
conn.send(stderr)

except Exception:
break
conn.close()

phone.close()

#此方法的问题是最大只能发小于2G的内容
--------------------------------------------------------------
定制报头的正确方式

客户端
import socket
import struct
import json

phone=socket.socket(socket.AF_INET,socket.SOCK_STREAM)
phone.connect((‘127.0.0.1‘,8080))

while True:
cmd=input(‘>>: ‘).strip()
if not cmd:continue
#发命令
phone.send(cmd.encode(‘utf-8‘))

#先收报头的长度
struct_res=phone.recv(4)
header_size=struct.unpack(‘i‘,struct_res)[0]

#再收报头
header_bytes=phone.recv(header_size)
head_json=header_bytes.decode(‘utf-8‘)
head_dic=json.loads(head_json)

total_size=head_dic[‘total_size‘]
#再收命令的执行结果
recv_size=0
data=b‘‘ #结果
while recv_size < total_size:
recv_data=phone.recv(1024)
recv_size+=len(recv_data)
data+=recv_data

print(data.decode(‘gbk‘))

phone.close()

 

服务端

import socket
import struct
import subprocess
import json

phone=socket.socket(socket.AF_INET,socket.SOCK_STREAM)
phone.setsockopt(socket.SOL_SOCKET,socket.SO_REUSEADDR,1)
phone.bind((‘127.0.0.1‘,8080))
phone.listen(5)
print(‘server start...‘)
while True:
conn,client_addr=phone.accept()
print(conn,client_addr)
while True:
try:
cmd=conn.recv(1024)
if not cmd:break

res=subprocess.Popen(cmd.decode(‘utf-8‘),
shell=True,
stdout=subprocess.PIPE,
stderr=subprocess.PIPE)

stdout=res.stdout.read()
stderr=res.stderr.read()

#制作报头
header_dic={‘total_size‘:len(stdout)+len(stderr),‘md5‘:None}
header_json=json.dumps(header_dic)
header_bytes=header_json.encode(‘utf-8‘)

#先发报头的长度(固定4个bytes)
conn.send(struct.pack(‘i‘,len(header_bytes)))

#再发报头
conn.send(header_bytes)

#再发真实数据
conn.send(stdout)
conn.send(stderr)

except Exception:
break
conn.close()

phone.close()

------------------------------------------------------------------
socketserver实现并发

服务端
import socketserver

class MyTcphandler(socketserver.BaseRequestHandler):
def handle(self):
while True: #通信循环
data=self.request.recv(1024) # 这个self.request就是conn
self.request.send(data.upper())

if __name__ == ‘__main__‘:
#取代链接循环
server=socketserver.ThreadingTCPServer((‘127.0.0.1‘,8080),MyTcphandler)
server.serve_forever()

 

客户端1
import socket

phone=socket.socket(socket.AF_INET,socket.SOCK_STREAM)
phone.connect((‘127.0.0.1‘,8080))

while True:
msg=input(‘>>: ‘).strip()
if not msg:continue
phone.send(msg.encode(‘utf-8‘))
server_data=phone.recv(1024)
print(server_data.decode(‘utf-8‘))

phone.close()

客户端2
import socket

phone=socket.socket(socket.AF_INET,socket.SOCK_STREAM)
phone.connect((‘127.0.0.1‘,8080))

while True:
msg=input(‘>>: ‘).strip()
if not msg:continue
phone.send(msg.encode(‘utf-8‘))
server_data=phone.recv(1024)
print(server_data.decode(‘utf-8‘))

phone.close()

客户端3
import socket

phone=socket.socket(socket.AF_INET,socket.SOCK_STREAM)
phone.connect((‘127.0.0.1‘,8080))

while True:
msg=input(‘>>: ‘).strip()
if not msg:continue
phone.send(msg.encode(‘utf-8‘))
server_data=phone.recv(1024)
print(server_data.decode(‘utf-8‘))

phone.close()