Python基础知识学习_Day8

一、类的扩展方法

1.静态方法

语法：@staticmethod，静态方法不能访问公有属性，不能访问类。可在实例化后直接调用，并且在方法里可以通过self.调用实例变量或类变量。

 class eat(object):
     def __init__(self,name):
         self.name = name
     @staticmethod #静态方法不能访问共有属性、不能访问实例
     def eat(name,food):
         print("%s is eating..%s" %(name,food))
 p.eat("alex","food")

2.类方法

语法：@classmethod,只能访问类的公有属性，不能访问实例属性。

 class Dog(object):
     name = "我是类变量"
     def __init__(self,name):
         self.name = name

     @classmethod
     def eat(self):
         print("%s is eating" % self.name)

 d = Dog("ChenRonghua")
 d.eat()

 #执行结果

 我是类变量 is eating

3.属性方法

语法：@property 把一个方法变成静态属性

 class Dog(object):

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

     @property
     def eat(self):
         print(" %s is eating" %self.name)

 d = Dog("ChenRonghua")
 d.eat

属性方法之航班查询代码

 class Flight(object):
     def __init__(self,name):
         self.flight_name = name

     def checking_status(self):
         print("checking flight %s status " % self.flight_name)
         return  1

     @property
     def flight_status(self):
         status = self.checking_status()
         if status == 0 :
             print("flight got canceled...")
         elif status == 1 :
             print("flight is arrived...")
         elif status == 2:
             print("flight has departured already...")
         else:
             print("cannot confirm the flight status...,please check later")

     @flight_status.setter #修改
     def flight_status(self,status):
         status_dic = {
 : "canceled",
 :"arrived",
 : "departured"
         }
         print("\033[31;1mHas changed the flight status to \033[0m",status_dic.get(status) )

     @flight_status.deleter  #删除
     def flight_status(self):
         print("status got removed...")

 f = Flight("CA980")
 f.flight_status
 f.flight_status =  2 #触发@flight_status.setter
 del f.flight_status #触发@flight_status.deleter

4.抽象类

抽象类本身不能被实例化，只能用来被别人继承

上面定义之后，被继承的必须有该方法，也就是上面只定义功能，下面定义实现方法

 class AllFile(metaclass=abc.ABCMeta):
     @abc.abstractclassmethod
     def read(self):
         pass
     def write(self):
         pass

 class Text(AllFile):
     def read(self):
         print('text read')
     def write(self):
         print('text write')

 t = Text()

 class Alert(object):
     def send(self):
         raise NotImplementedError
 class MailAlert(Alert):
     def send(self,msg):
         print("---sending..",msg)
 class SMSAlert(Alert):
     pass
 m = MailAlert()
 m.send("df")

二.类的特殊成员方法

1.__doc__ 表示类的描述信息

2.__module__表示当前操作的对象在哪个模块

3.__class__ 表示当前操作的对象的类是什么

class C:

    def __init__(self):
        self.name = 'wupeiqi'

from lib.aa import C

obj = C()
print obj.__module__  # 输出 lib.aa，即：输出模块
print obj.__class__      # 输出 lib.aa.C，即：输出类

4.__init__构造方法，通过类创建对象时，自动触发执行。

5.__del__ 析构方法，当对象在内存中被释放时，自动触发执行。此方法一般无需定义，python是一门高级语言，程序员在使用时无需关心内存的分配和释放，此工作都是交给python解释器来执行，所以，析构函数的调用是有解释器在进行垃圾回收时自动触发执行的。

6.__call__ 对象后面加括号，触发执行。

7.__dict__查看类或对象中所有的成员

三.反射

通过字符串映射或修改程序运行的状态、属性、方法。

python中的反射功能是由以下四个内置函数提供：hasattr、getattr、setattr、delattr，改四个函数分别用于对对象内部执行：检查是否含有某成员、获取成员、设置成员、删除成员。

hasattr(容器,'名称')  #以字符串的形式判断某个对象中是否含有指定的属性

getattr(容器,'名称')  #以字符串的形式去某个对象中获取指定的属性

setattr(容器,'名称',值)  #以字符串的形式去某个对象中设置指定的属性

delattr(容器,'名称')  #以字符串的形式去某个对象中删除指定的属性

代码如下：

 while True:
     inp = input("请输入url>>:")
     m,n = inp.split("/")
     try:
         module = __import__('controller.%s'%m,fromlist = True)
         if hasattr(module,n):
             func = getattr(module,n)
             result = func()
     except Exception as e:
         result = 500
     print(result)

四.异常处理

在编程过程中为了增加友好性，在程序出现bug时一般不会将错误信息显示给用户，而是现实一个提示的页面，通俗来说就是不让用户看见大黄页！！！

常见种类：

 AttributeError 试图访问一个对象没有的树形，比如foo.x，但是foo没有属性x
 IOError 输入/输出异常；基本上是无法打开文件
 ImportError 无法引入模块或包；基本上是路径问题或名称错误
 IndentationError 语法错误（的子类） ；代码没有正确对齐
 IndexError 下标索引超出序列边界，比如当x只有三个元素，却试图访问x[5]
 KeyError 试图访问字典里不存在的键
 KeyboardInterrupt Ctrl+C被按下
 NameError 使用一个还未被赋予对象的变量
 SyntaxError Python代码非法，代码不能编译(个人认为这是语法错误，写错了）
 TypeError 传入对象类型与要求的不符合
 UnboundLocalError 试图访问一个还未被设置的局部变量，基本上是由于另有一个同名的全局变量，
 导致你以为正在访问它
 ValueError 传入一个调用者不期望的值，即使值的类型是正确的

常见种类

 try:
     int('add')
     li = [11,22]
     li[100]
 except IndexError as e:  #符合的情况下执行
     print("",e)
 except ValueError as e:  #符合的情况下执行
     print("",e)
 except Exception as e:  #都能匹配到，以上不满足的情况下，匹配该项。
     print("",e)
 else:
     print("else")
 finally:
     print("finally")  #最后肯定会执行

五.socket编程

socket本质上就是在2台网络互通的电脑之间，架设一个通道，两台电脑通过这个通道来实现数据的互相传递。

socket Families 地址簇：socket.AF_INET    #IPV4

socket.SOCK_STREAM    #for tcp

socket.SOCK_DGRAM     #for udp

socket.SOCK_RAM         #原始套接字

socket方法：

socket.socket(family=AF_INET, type=SOCK_STREAM, proto=0, fileno=None)

sk.bind(address)  将套接字绑定到地址

sk.listen(backlog)  #开始监听传入连接。backlog指定在拒绝连接之前，可以挂起的最大连接数量。

sk.setblocking(bool)

　　是否阻塞（默认True），如果设置False，那么accept和recv时一旦无数据，则报错。

sk.accept()

　　接受连接并返回（conn,address）,其中conn是新的套接字对象，可以用来接收和发送数据。address是连接客户端的地址。

　　接收TCP 客户的连接（阻塞式）等待连接的到来

sk.connect(address)

　　连接到address处的套接字。一般，address的格式为元组（hostname,port）,如果连接出错，返回socket.error错误。

sk.connect_ex(address)

　　同上，只不过会有返回值，连接成功时返回 0 ，连接失败时候返回编码，例如：10061

sk.close()

　　关闭套接字

sk.recv(bufsize[,flag])

　　接受套接字的数据。数据以字符串形式返回，bufsize指定最多可以接收的数量。flag提供有关消息的其他信息，通常可以忽略。

sk.recvfrom(bufsize[.flag])

　　与recv()类似，但返回值是（data,address）。其中data是包含接收数据的字符串，address是发送数据的套接字地址。

sk.send(string[,flag])

　　将string中的数据发送到连接的套接字。返回值是要发送的字节数量，该数量可能小于string的字节大小。即：可能未将指定内容全部发送。

sk.sendall(string[,flag])

　　将string中的数据发送到连接的套接字，但在返回之前会尝试发送所有数据。成功返回None，失败则抛出异常。

内部通过递归调用send，将所有内容发送出去。

sk.sendto(string[,flag],address)

　　将数据发送到套接字，address是形式为（ipaddr，port）的元组，指定远程地址。返回值是发送的字节数。该函数主要用于UDP协议。

sk.settimeout(timeout)

　　设置套接字操作的超时期，timeout是一个浮点数，单位是秒。值为None表示没有超时期。一般，超时期应该在刚创建套接字时设置，因为它们可能用于连接的操作（如 client 连接最多等待5s ）

sk.getpeername()

　　返回连接套接字的远程地址。返回值通常是元组（ipaddr,port）。

sk.getsockname()

　　返回套接字自己的地址。通常是一个元组(ipaddr,port)

sk.fileno()

　　套接字的文件描述符

代码举例如下：

 import socket
 import subprocess
 server = socket.socket(socket.AF_INET,socket.SOCK_STREAM)
 server.bind(("127.0.0.1",8000))
 server.listen(5)
 print("-----start to listen------")
 while True:
     conn,client_addr = server.accept()
     print(conn,client_addr)
     while True:
         try:
             data = conn.recv(1024)
             if not data:
                 print("客户端已断开")
                 break
             print("recv from cli:",data)
             res_obj = subprocess.Popen(data,shell=True,stdout=subprocess.PIPE,stderr=subprocess.PIPE)
             res = res_obj.stdout.read()
             if len(res) ==0:
                 cmd_res = "cmd has no output..."
             conn.send(str(len(res)).encode())
             print("--res len:",len(res))
             conn.send(res.encode("utf-8"))
             print("send done")
         except Exception as e:
             print(e)
 server.close()

 import socket
 client =socket.socket()
 client.connect(("localhost",8000))
 while True:
     msg = input(">>:").strip()
     if len(msg) == 0:continue
     client.send(msg.encode("utf-8"))
     print("send",msg)
     data = client.recv(1024)
     print("res:",data.decode())
     total_size=int(data.decode())
     received_size = 0
     res = b''
     while received_size < total_size:
         d = client.recv(1024)
         res +=d
         received_size +=len(d)
     print("----rece done-----")
     print(res.decode())
 client.close()