python基础--面向对象高级异常处理网络编程
Posted
tags:
篇首语：本文由小常识网(cha138.com)小编为大家整理，主要介绍了python基础--面向对象高级异常处理网络编程相关的知识，希望对你有一定的参考价值。
一、面向对象高级
1、接口与归一化设计
接口只是定义了一些方法，而没有去实现，多用于程序设计时，只是设计需要有什么样的功能，但是并没有实现任何功能，这些功能需要被另一个类（B）继承后，由 类B去实现其中的某个功能或全部功能。
在python中接口由抽象类和抽象方法去实现，接口是不能被实例化的，只能被别的类继承去实现相应的功能
归一化让使用者无需关心对象的类是什么，只需要知道这些对象都具备某些功能就可以了，这极大地降低了使用者的使用难度。
归一化使得高层的外部使用者可以不加区分的处理所有接口兼容的对象集合。
#抽象类加抽象方法就等于面向对象编程中的接口 from abc import ABCMeta,abstractmethod class interface(object): __metaclass__ = ABCMeta #指定这是一个抽象类 @abstractmethod #抽象方法 def Lee(self): pass def Marlon(self): pass class RelalizeInterfaceLee(interface):#必须实现interface中的所有函数，否则会编译错误 def __init__(self): print ‘这是接口interface的实现‘ def Lee(self): print ‘实现Lee功能‘ def Marlon(self): pass class RelalizeInterfaceMarlon(interface): #必须实现interface中的所有函数，否则会编译错误 def __init__(self): print ‘这是接口interface的实现‘ def Lee(self): pass def Marlon(self): print "实现Marlon功能"
2、封装---如何隐藏属性
在程序设计中，封装（Encapsulation）是对具体对象的一种抽象，即将某些部分隐藏起来，在程序外部看不到，其
含义是其他程序无法调用。
要了解封装，离不开“私有化”，就是将类或者是函数中的某些属性限制在某个区域之内，外部无法调用。
封装数据的主要原因是：保护隐私（把不想别人知道的东西封装起来）
封装方法的主要原因是：隔离复杂度（比如：电视机，我们看见的就是一个黑匣子，其实里面有很多电器元件，对于
用户来说，我们不需要清楚里面都有些元件，电视机把那些电器元件封装在黑匣子里，提供给用户的只是几个按钮接口，
通过按钮就能实现对电视机的操作。
#封装不是单纯意义的隐藏
#1：封装数据属性：将属性隐藏起来，然后对外提供访问属性的接口，关键是我们在接口内定制一些控制逻辑从而严格控制使用对数据属性的使用
#先看如何隐藏 class Foo: __N=111111 #_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：这种隐藏只是一种语法上变形操作，并不会将属性真正隐藏起来 # print(Foo.__dict__) # print(f.__dict__) # print(f._Foo__Name) # print(f._Foo__N) #2:这种语法级别的变形，是在类定义阶段发生的，并且只在类定义阶段发生 # Foo.__x=123123123123123123123123123123123123123123 # print(Foo.__dict__) # print(Foo.__x) # f.__x=123123123 # print(f.__dict__) # print(f.__x) #3:在子类定义的__x不会覆盖在父类定义的__x，因为子类中变形成了：_子类名__x,而父类中变形成了：_父类名__x，即双下滑线开头的属性在继承给子类时，子类是无法覆盖的。 class Foo: def __f1(self): #_Foo__f1 print(‘Foo.f1‘) def f2(self): self.__f1() #self._Foo_f1 class Bar(Foo): def __f1(self): #_Bar__f1 print(‘Bar.f1‘) # b=Bar() # b.f2()
3、封装的真实目的
封装函数属性：为了隔离复杂度
#取款是功能,而这个功能有很多功能组成:插卡、密码认证、输入金额、打印账单、取钱 #对使用者来说,只需要知道取款这个功能即可,其余功能我们都可以隐藏起来,很明显这么做 #隔离了复杂度,同时也提升了安全性 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() # _x=123
4、静态属性
Python的静态方法和类成员方法都可以被类或实例访问，两者概念不容易理清：
class TestClassMethod(object): METHOD = ‘method hoho‘ def __init__(self): self.name = ‘leon‘ def test1(self): print ‘test1‘ print self @classmethod def test2(cls): print cls print ‘test2‘ print TestClassMethod.METHOD print ‘----------------‘ @staticmethod def test3(): print TestClassMethod.METHOD print ‘test3‘ if __name__ == ‘__main__‘: a = TestClassMethod() a.test1() a.test2() a.test3() TestClassMethod.test3() test1为实例方法 test2为类方法，第一个参数为类本身 test3为静态方法，可以不接收参数 类方法和静态方法皆可以访问类的静态变量(类变量)，但不能访问实例变量，test2、test3是不能访问self.name的,而test1则可以
5、反射
一、前言
def f1():
print("f1是这个函数的名字！")
s = "f1"
print("%s是个字符串" % s)
在上面的代码中，我们必须区分两个概念，f1和“f1"。前者是函数f1的函数名，后者只是一个叫”f1“的字符串，两者是不同的事物。我们可以用f1()的方式调用函数f1，但我们不能用"f1"()的方式调用函数。说白了就是，不能通过字符串来调用名字看起来相同的函数！
二、web实例
考虑有这么一个场景，根据用户输入的url的不同，调用不同的函数，实现不同的操作，也就是一个url路由器的功能，这在web框架里是核心部件之一。下面有一个精简版的示例：
首先，有一个commons模块，它里面有几个函数，分别用于展示不同的页面，代码如下：
其次，有一个visit模块，作为程序入口，接受用户输入，展示相应的页面，代码如下：（这段代码是比较初级的写法）
我们运行visit.py，输入：home，页面结果如下：
这就实现了一个简单的WEB路由功能，根据不同的url，执行不同的函数，获得不同的页面。
然而，让我们考虑一个问题，如果commons模块里有成百上千个函数呢(这非常正常)?。难道你在visit模块里写上成百上千个elif?显然这是不可能的！那么怎么破？
三、反射机制
仔细观察visit中的代码，我们会发现用户输入的url字符串和相应调用的函数名好像！如果能用这个字符串直接调用函数就好了！但是，前面我们已经说了字符串是不能用来调用函数的。为了解决这个问题，python为我们提供一个强大的内置函数：getattr!我们将前面的visit修改一下，代码如下：
|
1
2
3
4
5
6
7
8
9
|
import commons def run(): inp = input("请输入您想访问页面的url： ").strip() func = getattr(commons,inp) func() if __name__ == ‘__main__‘: run() |
首先说明一下getattr函数的使用方法：它接收2个参数，前面的是一个对象或者模块，后面的是一个字符串，注意了！是个字符串！
例子中，用户输入储存在inp中，这个inp就是个字符串，getattr函数让程序去commons这个模块里，寻找一个叫inp的成员（是叫，不是等于），这个过程就相当于我们把一个字符串变成一个函数名的过程。然后，把获得的结果赋值给func这个变量，实际上func就指向了commons里的某个函数。最后通过调用func函数，实现对commons里函数的调用。这完全就是一个动态访问的过程，一切都不写死，全部根据用户输入来变化。
执行上面的代码，结果和最开始的是一样的。
这就是python的反射，它的核心本质其实就是利用字符串的形式去对象（模块）中操作（查找/获取/删除/添加）成员，一种基于字符串的事件驱动！
这段话，不一定准确，但大概就是这么个意思。
四、进一步完善
上面的代码还有个小瑕疵，那就是如果用户输入一个非法的url，比如jpg，由于在commons里没有同名的函数，肯定会产生运行错误，具体如下：
|
1
2
3
4
5
6
7
|
请输入您想访问页面的url： jpg Traceback (most recent call last): File "F:/Python/pycharm/s13/reflect/visit.py", line 16, in <module> run() File "F:/Python/pycharm/s13/reflect/visit.py", line 11, in run func = getattr(commons,inp) AttributeError: module ‘commons‘ has no attribute ‘jpg‘ |
那怎么办呢？其实，python考虑的很全面了，它同样提供了一个叫hasattr的内置函数，用于判断commons中是否具有某个成员。我们将代码修改一下：
|
1
2
3
4
5
6
7
8
9
10
11
12
|
import commons def run(): inp = input("请输入您想访问页面的url： ").strip() if hasattr(commons,inp): func = getattr(commons,inp) func() else: print("404") if __name__ == ‘__main__‘: run() |
通过hasattr的判断，可以防止非法输入错误，并将其统一定位到错误页面。
其实，研究过python内置函数的朋友，应该注意到还有delattr和setattr两个内置函数。从字面上已经很好理解他们的作用了。
python的四个重要内置函数：getattr、hasattr、delattr和setattr较为全面的实现了基于字符串的反射机制。他们都是对内存内的模块进行操作，并不会对源文件进行修改。
7、item系列
这个Item系列是egon老师自创的,个人还是可以接受这种文化底蕴的,所以直接拿来用,也是毫无违和感的
所谓Attr系列,其实是__setattr__,__delattr__,__getattr__ 三个函数,从名字中可以看出来这是一套设置,删除,查询的函数,那我们来一个一个的看:
__setitem__(self,key,value):当对类中的某个属性进行"赋值"时触发的函数(只有使用字典赋值的方式时才会触发此方法的执行)
与Attr系列的区分:__setattr__(self):是在对象打点儿的方式赋值时,才会触发的方法
代码示例:
class Foo:
def __setitem__(self, key, value):
print(key,"获得",value)
f = Foo()
f["name"] = "egon"
__delitem__(self,key):当类中的某个属性被删除时,触发此方法(只有使用del字典方式删除属性时,才会触发此方法)
与Attr系列的区分:__delattr__(self):使用del类打点儿属性的方式删除属性,才会触发此方法
代码示例:
1 class Foo: 2 name = "egon" 3 def __delitem__(self, key): 4 print(key,"已被删除") 5 f = Foo() 6 del f["name"]
__getitem__(self,item):当调用类中的属性或方法时触发此方法的执行(只在使用类[key]字典的方式调用时,才会触发此方法)
与Attr系列的区分:其实这里已经很明显了,__getattr__(self):是类打点儿调用且命名空间没有发现名字的情况下,触发此方法
代码示例:
1 class Foo: 2 name = "egon" 3 def __getitem__(self, item): 4 print(item,"已被调用") 5 f = Foo() 6 f["name"]
8、打印对象信息_str__
__str__方法和__init__方法类似，都是一些特殊方法，所以前后都有双下划线，它用来返回对象的字符串表达式。
例如，下面是一个时间对象的str方法：
#玩蛇网提示：代码用来讲解__str__的概念，初学者请先了解类class的概念。
#类内部的一个函数
def __str__(self):
return ‘%.2d:%.2d:%.2d‘ % (self.hour, self.minute, self.second)
当你用print打印输出的时候，Python会调用它的str方法，如下：
>>> time = Time(9, 45) >>> print time 09:45:23
在我们编写一个新的Python类的时候，总是在最开始位置写一个初始化方法__init__，以便初始化对象，然后会写一个__str__方法，方面我们调试程序。
9、析构方法__del__
示例程序如下： >>> a = [-1, 3, ‘aa‘, 85] # 定义一个list >>> a [-1, 3, ‘aa‘, 85] >>> del a[0] # 删除第0个元素 >>> a [3, ‘aa‘, 85] >>> del a[2:4] # 删除从第2个元素开始，到第4个为止的元素。包括头不包括尾 >>> a [3, ‘aa‘] >>> del a # 删除整个list >>> a Traceback (most recent call last): File "<stdin>", line 1, in <module> NameError: name ‘a‘ is not defined >>>
二、异常处理
python提供了两个非常重要的功能来处理python程序在运行中出现的异常和错误。你可以使用该功能来调试python程序。
python标准异常
| 异常名称 | 描述 |
|---|---|
| BaseException | 所有异常的基类 |
| SystemExit | 解释器请求退出 |
| KeyboardInterrupt | 用户中断执行(通常是输入^C) |
| Exception | 常规错误的基类 |
| StopIteration | 迭代器没有更多的值 |
| GeneratorExit | 生成器(generator)发生异常来通知退出 |
| StandardError | 所有的内建标准异常的基类 |
| ArithmeticError | 所有数值计算错误的基类 |
| FloatingPointError | 浮点计算错误 |
| OverflowError | 数值运算超出最大限制 |
| ZeroDivisionError | 除(或取模)零 (所有数据类型) |
| AssertionError | 断言语句失败 |
| AttributeError | 对象没有这个属性 |
| EOFError | 没有内建输入,到达EOF 标记 |
| EnvironmentError | 操作系统错误的基类 |
| IOError | 输入/输出操作失败 |
| OSError | 操作系统错误 |
| WindowsError | 系统调用失败 |
| ImportError | 导入模块/对象失败 |
| LookupError | 无效数据查询的基类 |
| IndexError | 序列中没有此索引(index) |
| KeyError | 映射中没有这个键 |
| MemoryError | 内存溢出错误(对于Python 解释器不是致命的) |
| NameError | 未声明/初始化对象 (没有属性) |
| UnboundLocalError | 访问未初始化的本地变量 |
| ReferenceError | 弱引用(Weak reference)试图访问已经垃圾回收了的对象 |
| RuntimeError | 一般的运行时错误 |
| NotImplementedError | 尚未实现的方法 |
| SyntaxError | Python 语法错误 |
| IndentationError | 缩进错误 |
| TabError | Tab 和空格混用 |
| SystemError | 一般的解释器系统错误 |
| TypeError | 对类型无效的操作 |
| ValueError | 传入无效的参数 |
| UnicodeError | Unicode 相关的错误 |
| UnicodeDecodeError | Unicode 解码时的错误 |
| UnicodeEncodeError | Unicode 编码时错误 |
| UnicodeTranslateError | Unicode 转换时错误 |
| Warning | 警告的基类 |
| DeprecationWarning | 关于被弃用的特征的警告 |
| FutureWarning | 关于构造将来语义会有改变的警告 |
| OverflowWarning | 旧的关于自动提升为长整型(long)的警告 |
| PendingDeprecationWarning | 关于特性将会被废弃的警告 |
| RuntimeWarning | 可疑的运行时行为(runtime behavior)的警告 |
| SyntaxWarning | 可疑的语法的警告 |
| UserWarning | 用户代码生成的警告 |
什么是异常？
异常即是一个事件，该事件会在程序执行过程中发生，影响了程序的正常执行。
一般情况下，在Python无法正常处理程序时就会发生一个异常。
异常是Python对象，表示一个错误。
当Python脚本发生异常时我们需要捕获处理它，否则程序会终止执行。
异常处理
捕捉异常可以使用try/except语句。
try/except语句用来检测try语句块中的错误，从而让except语句捕获异常信息并处理。
如果你不想在异常发生时结束你的程序，只需在try里捕获它。
语法：
以下为简单的try....except...else的语法：
try:
<语句> #运行别的代码
except <名字>：
<语句> #如果在try部份引发了‘name‘异常
except <名字>，<数据>:
<语句> #如果引发了‘name‘异常，获得附加的数据
else:
<语句> #如果没有异常发生
try的工作原理是，当开始一个try语句后，python就在当前程序的上下文中作标记，这样当异常出现时就可以回到这里，try子句先执行，接下来会发生什么依赖于执行时是否出现异常。
- 如果当try后的语句执行时发生异常，python就跳回到try并执行第一个匹配该异常的except子句，异常处理完毕，控制流就通过整个try语句（除非在处理异常时又引发新的异常）。
- 如果在try后的语句里发生了异常，却没有匹配的except子句，异常将被递交到上层的try，或者到程序的最上层（这样将结束程序，并打印缺省的出错信息）。
- 如果在try子句执行时没有发生异常，python将执行else语句后的语句（如果有else的话），然后控制流通过整个try语句。
实例
下面是简单的例子，它打开一个文件，在该文件中的内容写入内容，且并未发生异常：
#!/usr/bin/python
# -*- coding: UTF-8 -*-
try:
fh = open("testfile", "w")
fh.write("这是一个测试文件，用于测试异常!!")
except IOError:
print "Error: 没有找到文件或读取文件失败"
else:
print "内容写入文件成功"
fh.close()
以上程序输出结果：
$ python test.py
内容写入文件成功
$ cat testfile # 查看写入的内容
这是一个测试文件，用于测试异常!!
实例
下面是简单的例子，它打开一个文件，在该文件中的内容写入内容，但文件没有写入权限，发生了异常：
#!/usr/bin/python
# -*- coding: UTF-8 -*-
try:
fh = open("testfile", "w")
fh.write("这是一个测试文件，用于测试异常!!")
except IOError:
print "Error: 没有找到文件或读取文件失败"
else:
print "内容写入文件成功"
fh.close()
在执行代码前为了测试方便，我们可以先去掉 testfile 文件的写权限，命令如下：
chmod -w testfile
再执行以上代码：
$ python test.py
Error: 没有找到文件或读取文件失败
使用except而不带任何异常类型
你可以不带任何异常类型使用except，如下实例：
try:
正常的操作
......................
except:
发生异常，执行这块代码
......................
else:
如果没有异常执行这块代码
以上方式try-except语句捕获所有发生的异常。但这不是一个很好的方式，我们不能通过该程序识别出具体的异常信息。因为它捕获所有的异常。
使用except而带多种异常类型
你也可以使用相同的except语句来处理多个异常信息，如下所示：
try:
正常的操作
......................
except(Exception1[, Exception2[,...ExceptionN]]]):
发生以上多个异常中的一个，执行这块代码
......................
else:
如果没有异常执行这块代码
try-finally 语句
try-finally 语句无论是否发生异常都将执行最后的代码。
try:
<语句>
finally:
<语句> #退出try时总会执行
raise
实例
#!/usr/bin/python
# -*- coding: UTF-8 -*-
try:
fh = open("testfile", "w")
fh.write("这是一个测试文件，用于测试异常!!")
finally:
print "Error: 没有找到文件或读取文件失败"
如果打开的文件没有可写权限，输出如下所示：
$ python test.py
Error: 没有找到文件或读取文件失败
同样的例子也可以写成如下方式：
#!/usr/bin/python
# -*- coding: UTF-8 -*-
try:
fh = open("testfile", "w")
try:
fh.write("这是一个测试文件，用于测试异常!!")
finally:
print "关闭文件"
fh.close()
except IOError:
print "Error: 没有找到文件或读取文件失败"
当在try块中抛出一个异常，立即执行finally块代码。
finally块中的所有语句执行后，异常被再次触发，并执行except块代码。
参数的内容不同于异常。
异常的参数
一个异常可以带上参数，可作为输出的异常信息参数。
你可以通过except语句来捕获异常的参数，如下所示：
try:
正常的操作
......................
except ExceptionType, Argument:
你可以在这输出 Argument 的值...
变量接收的异常值通常包含在异常的语句中。在元组的表单中变量可以接收一个或者多个值。
元组通常包含错误字符串，错误数字，错误位置。
实例
以下为单个异常的实例：
#!/usr/bin/python
# -*- coding: UTF-8 -*-
# 定义函数
def temp_convert(var):
try:
return int(var)
except ValueError, Argument:
print "参数没有包含数字\n", Argument
# 调用函数
temp_convert("xyz");
以上程序执行结果如下：
$ python test.py
参数没有包含数字
invalid literal for int() with base 10: ‘xyz‘
触发异常
我们可以使用raise语句自己触发异常
raise语法格式如下：
raise [Exception [, args [, traceback]]]
语句中Exception是异常的类型（例如，NameError）参数是一个异常参数值。该参数是可选的，如果不提供，异常的参数是"None"。
最后一个参数是可选的（在实践中很少使用），如果存在，是跟踪异常对象。
实例
一个异常可以是一个字符串，类或对象。 Python的内核提供的异常，大多数都是实例化的类，这是一个类的实例的参数。
定义一个异常非常简单，如下所示：
def functionName( level ):
if level < 1:
raise Exception("Invalid level!", level)
# 触发异常后，后面的代码就不会再执行
注意：为了能够捕获异常，"except"语句必须有用相同的异常来抛出类对象或者字符串。
例如我们捕获以上异常，"except"语句如下所示：
try:
正常逻辑
except "Invalid level!":
触发自定义异常
else:
其余代码
实例
#!/usr/bin/python
# -*- coding: UTF-8 -*-
# 定义函数
def mye( level ):
if level < 1:
raise Exception("Invalid level!", level)
# 触发异常后，后面的代码就不会再执行
try:
mye(0) // 触发异常
except "Invalid level!":
print 1
else:
print 2
执行以上代码，输出结果为：
$ python test.py
Traceback (most recent call last):
File "test.py", line 11, in <module>
mye(0)
File "test.py", line 7, in mye
raise Exception("Invalid level!", level)
Exception: (‘Invalid level!‘, 0)
用户自定义异常
通过创建一个新的异常类，程序可以命名它们自己的异常。异常应该是典型的继承自Exception类，通过直接或间接的方式。
以下为与RuntimeError相关的实例,实例中创建了一个类，基类为RuntimeError，用于在异常触发时输出更多的信息。
在try语句块中，用户自定义的异常后执行except块语句，变量 e 是用于创建Networkerror类的实例。
class Networkerror(RuntimeError):
def __init__(self, arg):
self.args = arg
在你定义以上类后，你可以触发该异常，如下所示：
try:
raise Networkerror("Bad hostname")
except Networkerror,e:
print e.args
三、网络编程
1、网络协议
Socket 是进程间通信的一种方式，它与其他进程间通信的一个主要不同是：它能实现不同主机间的进程间通信，我们网络上各种各样的服务大多都是基于 Socket 来完成通信的，例如我们每天浏览网页、QQ 聊天、收发 email 等等。要解决网络上两台主机之间的进程通信问题，首先要唯一标识该进程，在 TCP/IP 网络协议中，就是通过 (IP地址，协议，端口号) 三元组来标识进程的，解决了进程标识问题，就有了通信的基础了。
本文主要介绍使用 Python 进行 TCP Socket 网络编程，假设你已经具有初步的网络知识及 Python 基本语法知识。
TCP 是一种面向连接的传输层协议，TCP Socket 是基于一种 Client-Server 的编程模型，服务端监听客户端的连接请求，一旦建立连接即可以进行传输数据。那么对 TCP Socket 编程的介绍也分为客户端和服务端
2、基于tcp协议的socket实现简单通信
#服务端代码 import socket phone=socket.socket(socket.AF_INET,socket.SOCK_STREAM) phone.setsockopt(socket.SOL_SOCKET,socket.SO_REUSEADDR,1) #就是它，在bind前加 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) # print(‘has rev‘) 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‘)) # print(‘====>has send‘) server_data=phone.recv(1024) # print(‘====>has recv‘) print(server_data.decode(‘utf-8‘)) phone.close()
3、模拟ssh远程执行命令
#服务器端代码 import socket import subprocess phone=socket.socket(socket.AF_INET,socket.SOCK_STREAM) phone.setsockopt(socket.SOL_SOCKET,socket.SO_REUSEADDR,1) #就是它，在bind前加 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() conn.send(stdout+stderr) except Exception: #针对windwos break conn.close() phone.close() #客户端代码 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‘)) phone.close()
4、解决黏包问题
#服务器端代码 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) #就是它，在bind前加 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‘) #1 先发报头的长度（固定4个bytes） conn.send(struct.pack(‘i‘,len(header_bytes))) #2 先发报头 conn.send(header_bytes) #3 再发真实的数据 conn.send(stdout) conn.send(stderr) except Exception: #针对windwos break conn.close() phone.close() #客户端代码 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()
以上是关于python基础--面向对象高级异常处理网络编程的主要内容，如果未能解决你的问题，请参考以下文章