面向对象与网络编程的总结

面向对象与网络编程的总结

一、面向对象

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简单通信

书写步骤同上

转载于:https://www.cnblogs.com/demiao/p/11502921.html