面向对象与网络编程的总结
一、面向对象
1.1 类和对象
1.类和对象
#类
class 类名：
pass
2.获取类的属性和方法
类.__dict__
3.类调用属性和方法
类名.属性/方法
4.产生对象
类加括号产生对象
5.对象获取属性和方法
对象.__dict__
6.对象调用属性和方法
对象.属性/函数
7.属性查找顺序
自身-->类——>报错
8.对象赋属性
1）
stu1 = Student()
stu1.name = 'nick'
2)通过__init__
-在类中定义该方法,方法上写一些参数
-在对象实例化产生对象时,在括号中传的值,会被传到__init__中
class Student:
school = 'oldboy' #变量表示属性
def __init__(self,name):
self.name=name
stu1=Student('jiayi')
print(stu1.name)
9.绑定方法
定义在类内部的方法
-类来调用:就是一个普通函数,有几个参数就需要传几个参数
-对象来调用:它叫对象的绑定方法,第一个参数不需要传,自动传递
1.2 继承
继承了一个类，类中的属性和方法就在子类中了
1.新式类和经典类
新式类：继承object类，py3中默认都是新式类
经典类：不继承object类，py2中有经典类和新式类之分
2.多层继承
class D(object): #D继承object
pass
class C(D):
pass
class B(C):
pass
class A(B): #A继承B,C,D
pass
3.多继承
class D: #D继承object
pass
class C:
pass
class B:
pass
class A(B,C,D): #A继承B,C,D
pass
4.继承的菱形问题
新式类：广度优先
经典类：深度优先
5.属性的查找顺序
对象----类---父类----报错
6.重用父类的方法
1）指名道姓的用
2)super()方法，遵循mro列表
7.组合
对象的属性是另一个对象
class Foo:
pass
class Bar:
pass
f = Foo()
f.bar = Bar()
8.什么时候用继承，什么时候用组合
继承：什么是什么 eg：学生、老师都是人
组合：什么有什么 eg：学生、老师都有课程这个方法
1.3 多态与多态性
多态：一种事物的多种体现
多态性：调用同一个函数，有不同的实现方法，一种接口，多种实现
1.如何用多态
1）abc实现接口统一化
2）raise抛异常
2.鸭子类型
外形，走路像鸭子就是鸭子，人为约束
3.多态性的好处
1）增加程序的灵活性
2）增加了程序的可扩展性
1.4 封装
1.什么是封装
隐藏对象的属性和方法，仅对外提供公共访问接口
2.封装的实现
-
隐藏属性：提高安全性
__变量名 -
隐藏方法：隔离复杂度
__方法名
3.property装饰器
把方法包装成数据属性
1.5 绑定方法和非绑定方法
1.类的绑定方法
绑定给类，类来调用，会把类自身传过去（拿到一个类就得到一个对象）
2.classmethod和staticmethod装饰器
classmethod：类的绑定方法，可以类来调用，对象也可以调用，只是默认传递的第一个参数还是这个对象对应的类
staticmethod：静态绑定方法，定义在类内部，谁都不绑定，谁都可以调用
3.issubclass和isinstance
issubclass:判断第一个类是不是第二个类的子类
isinstance：判断第一个参数是不是第二个参数的对象，返回True或Flase
1.6 反射和内置方法
1.反射
- hasattr():判断一个属性是否在对象中，返回True或Flase
- getattr():通过字符串获取属性和方法，如果获取到了，就会返回相应的属性和方法
- setattr():通过字符串设置属性和方法
- delattr():通过字符串删除属性和方法
2.点拦截方法
__getattr__：如果去对象中取属性，一旦取不到，会进入到__getattr__
__setattr__：如果去对象中赋值属性，一旦取不到，会进入__setattr__
__delattr__：如果删除对象中的属性,一旦取不到，会进入__delattr__
3.__item__系列
对象通过[]取值、赋值、删除值的时候会调用
4.上下文管理器
本质就是__enter和__exit__
1.7 元类
实例化产生类的类
1.class底层原理分析
type传一堆参数实例化产生一个Person类
type(object_or_name, bases, dict)分别传三个参数
2.三个魔法方法
__init__：初始化空对象
__call__：控制对象的产生
__new__:创建空对象
3.有了元类之后的查找顺序
- 类的查找顺序：类本身---父类--自定义元类---type元类---报错
- 对象的查找顺序：自身---类---父类---报错
1.8 单例模式
1.通过类的绑定方法
class Sql():
_instance = None
def __init__(self,port,host):
self.port = port
self.host = host
@classmethod
def get_singleton(cls):
import settings
if not cls._instance:
cls._instance = cls(settings.PORT,settings.HOST)
return cls._instance
2.通过装饰器
import settings
def get_singleton(cls):
_instance = cls(settings.PORT,settings.HOST)
def wrapper(*args,**kwargs):
if len(args) ==0 and len(kwargs) == 0:
return _instance
return cls(*args,**kwargs)
return wrapper
@get_singleton
class Sql():
def __init__(self,port,host):
self.port = port
self.host = host
3.通过元类实现
import settings
class Mymeta(type):
def __init__(self,name,bases,dic): #self是Sql类
self._instance = self(settings.PORT,settings.HOST)
def __call__(self, *args, **kwargs): #self是Sql类
if len(args) == 0 and len(kwargs) == 0:
return self._instance
obj = object.__new__(self)
obj.__init__(*args, **kwargs)
return obj
4.通过导入模块实现
def test():
from singleton import s1
print(s1) #这个s1和下面的s1不是一个，但是值相同
def test2():
from singleton import s1,Sql
print(s1) #这个s1和上面的s1不是一个，但是值相同
obj = Sql(3306,'192.168.1.1') #传参的时候生成一个新的空对象
print(obj) #打印传进去的对象
二、网络编程
2.1协议
1.c/s和b/s架构
c/s:客户端和服务器
b/s:浏览器和服务器，本质上还是客户端和服务器
2.osi五层
-
物理层：高低压电信号
-
数据链路层：数据报、mac地址
-
网络层：IP协议和端口号（IP可以通过arp协议，和mac地址进行转换）
-
传输层:TCP和UDP协议
TCP:基于数据流的可靠协议（三次握手、四次挥手）
UDP：基于数据报的不可靠协议
- 应用层：http协议，邮件协议等
2.2 socket
在传输层和应用层之间的一层抽象层，可以操作网络层和传输层
1.用套接字实现tcp协议的通信
2.用套接字实现的UDP协议的通信
3.发生粘包的两种情况
- 发送端需要等缓冲区满才发送出去，造成粘包(发送时间间隔很短，数据又很小，会合到一起，产生粘包)
- 接收端不及时接收缓冲区的包，造成多个包接收(客户端发送了一段数据，服务端只收了一小部分，服务端下次手的时候还是从缓冲区呐上次一流的数据，产生粘包)
4.解决粘包的问题
-
为字节流加上固定的报头，报头中含有字节流的长度，一次send到对端，对端在接收时，先从缓存中取出定长的报头，然后再取真实数据。
struct()模块，将数据长度打包为四个int型的字节
-
把报头做成字典，字典里面包含将要发送的真实数据长度，数据名，md5等等的信息，，然后json序列化，然后用struck将序列化后的数据长度打包成4个字节，一同send到对端
发送时： 先发报头长度 再编码报头内容然后发送 最后发真实内容 接收时： 先手报头长度，用struct取出来 根据取出的长度收取报头内容，然后解码，反序列化 从反序列化的结果中取出待取数据的详细信息，然后去取真实的数据内容
5.UDP协议
-
用udp实现简单通信
#服务器 import socket soc= socket.socket(socket.AF_INET,socket.SOCK_DGRAM) #socket.SOCK_DGRAM是UDP协议 soc.bind(('127.0.0.1',8080)) #绑定地址和端口号 while True: #通信循环 data,addr = soc.recvfrom(1024) #无需等待接收和监听 print(data) soc.sendto(data.upper(),addr) #将处理好的数据发送给客户端#客户端 import socket soc = socket.socket(socket.AF_INET,socket.SOCK_DGRAM) #实例化一个对象 while True: #通信循环 msg= input('请输入数据>>>').strip() msg = msg.encode('utf8') #将数据转化为bytes格式 soc.sendto(msg,('127.0.0.1',8080)) data = soc.recvfrom(1024) #接收数据 print(data[0]) #打印数 -
udp的特点：
可以发送空内容
不需要建立连接
客户端和服务端谁断开都不影响发送
不会粘包
6.socketserver模块
1） socketserver模块实现TCP简单通信
服务端
import socketserver
import struct
import os
from conf import settings
#自己定义一个类,必须继承BaseRequestHandler
class MyTcp(socketserver.BaseRequestHandler):
#必须重写handle方法
def handle(self):
try:
while True : #通信循环
###########
##逻辑代码##
###########
except Exception:
passsocketserver.ThreadingTCPServer(('127.0.0.1',8080),MyTcp)`
* `soc.serve_forever() `
客户端：用socket模块就行
2)socketserver模块实现UDP简单通信
书写步骤同上