day07 类的进阶，socket编程初识

类的静态方法：

正常：

添加静态方法：

就会变成一个函数，不会自动传self 参数，不会调用类的变量和实例的变量  不在需要self 

 

名义上归类管，但是它就是一个单独的函数，不在需要传入self，想怎么写就怎么写

 类似于：

 

就是一个os类里有许多的可用的函数方法，相当于一个工具包

静态方法只对下面一个函数有作用，  其实就是一个装饰器

类方法：

 

类里只能访问类变量，不能访问实例变量（初始化时候的变量）

 

强制方法使用类变量而不是实例变量：

 

 

属性方法：

把一个方法变为一个静态属性  （把函数变为一个变量）

 

 

 正确使用方法：

 

但是不能传变量，想传变量：

 

使用方法：

真正赋值：

想删除此变量 就删除

整合：

用处：

隐藏实现细节

 

 类的特殊成员方法：

写好注释

查看：

pinrt(Dog.__doc__)

返回C 是从哪里导入的

 

输出类

 

不加这个方法：

加入__call__ 方法：

或者这样写：

运行结果：

以一个字典的形式把类里的属性，方法 打印出来

 

通过实例调用，只打印实例变量：

 

作用： 可以查看实例里有什么变量（属性）

 

没有的话：

 

加上：

设置：

 

获取：

删除：  不是真的删除，就是走到这一步，执行这个函数

可以实现对字典的访问控制

 

把字典封装成一个实例，在用户删除数据时，做一个判断

 Foo  就是来自于type    Foo 后面的类就是type 类

归根结底：

 

常规创建类：

特殊方法创建类：

 实例化：

我们称type 为类的类

所有的类都是通过type 类创建的

 

 

新式类写法 用type写一个类

 

new 方法 是自动执行并先于init执行

真正实例化的时候会先走new  然后通过new 触发init

 

大多数情况下你都不要写。。。。。。

 

cls 是把Foo 传到父类里了

 

继承父类的new 方法，添加了一个print 功能

return 的是Foo的内存对象

call  来创建  new  

 

 

可以自己创建一个类的生成器  

自定义类生成器里可以添加一个东西，这样通过这个类来生成的类 都会有这个数据

 反射：

示例：

实现：  但是这样不行，所以需要用反射实现

正确方法：

1 通过 判断有没有这个方法：

用反射实现：

 调用

如果没有就没有，报错，所以需要提前加一个判断

来真正调用：  加上()

真正正常使用：

来定义一个：

 

 

不能调用变量，因为加了() 

可以更改变量：

 

 

实践：

class Dog(object):
    def __init__(self,name):
        self.name = name
    def eat(self):
        print("{_who} is eat food".format(_who=self.name))
d1 = Dog("dang")
print(d1.name)
chose = input("input:>>").strip()
#判断实例里是否有此方法或者属性
# if hasattr(d1,chose):
#     print("hava",chose)
# else:
#     print("not have",chose)
#如果有这个方法执行这个方法（属性的话直接使用，不能执行）
if hasattr(d1,chose):
    func = getattr(d1,chose)
    func()
else:
    print("not have", chose)
# #改变实例中的属性 
# if hasattr(d1,chose):
#     setattr(d1,chose,"heheh")
# else:
#     print("not have",chose)
#
#删除实例中的属性
if hasattr(d1,chose):
    delattr(d1,chose)
else:
    print("not have",chose)
print(d1.name)

 

hasattr  判断实例中是否有此属性或方法

 

getattr 获取属性 或 者执行方法

setattr 改变属性（变量）

delattr 删除属性  

 可以 判断 有就取出来，没有就设置然后出去来

异常处理：

使用 as 获取错误结果：

处理多个异常：

 

简写： 但是这样就不能知道是哪个错误了，所以一般不写

但是作用是有的，可以判断当限定的多种错误结果出现时都执行某个特定动作。

 

基本上所有的错误：

弊端就是 需要自己去判断到时什么出错了：

一般不用  没法调试   不建议一开始就用，而是放到最后用

 

 用在最后面抓所有未知错误：

 

一切正常就会走下面：

else  就是一切正常

 

 finally  不管有没有错都执行

常见的几种异常：

自定义错误：

触发自己写的异常：

Socket 网络编程

 

 

 协议类型：

套接字类型

 

 示例：

 client：

import socket
client = socket.socket()
client.connect(('localhost',6868))
client.send(b"Hello world!")
data = client.recv(1024)
print('recv:',data)
client.close()

 

server：

import socket
server = socket.socket()
server.bind(('localhost',6868)) #绑定要监听的地址
server.listen() #开始监听
print('我要开始等电话了')
conn,addr = server.accept() #等待电话打过来，接收客户端地址
print(conn,addr)
print('电话来了')
data = conn.recv(1024)
print('recv:',data)
conn.send(data.upper())
server.close()

 

 所有数据传输必须用byte 格式 

 

循环接收一个客户端

 改进 循环接收多个客户端而不推出

 

 最大允许多个连接，在一个通讯时，可以有几个等待的 在排队的   一般写5个 不到10个

 

 不能send  空  必须做一个判断 如果是空就不发

 

 

上面的操作都是把数据存到网卡的缓存中

数据会存到网卡的buffer 中  直到发完之前的才会发新的

服务器 最多一次发32k

 

解决办法

1循环 发送

 

2 使用sendall 

conn.sendall(data)