WEEK7：面向对象编程进阶

  • 面向对象高级语法部分
    • 静态方法、类方法、属性方法
      • 静态方法 @staticmethod #此方法实际上跟类已经没什么关系了，此时就是单纯的函数，无法直接调用类变量，但是可以通过传进去实例调用类变量。静态方法只是名义上归类管理，实际上在静态方法里访问不了类或者实例中的任何属性
         1 import os
 2 
 3 class Dog(object):
 4     def __init__(self,name):
 5         self.name = name
 6 
 7     @staticmethod #此方法实际上跟类已经没什么关系了，此时就是单纯的函数，无法直接调用类变量和实例变量，但是可以通过传进去实例调用实例变量
 8     def eat(self):
 9         print("%s is eating %s" %(self.name,'dd'))
10 
11     def talk(self):
12         print("%s is talking"% self.name)
13 d = Dog("ChenRonghua")
14 d.eat(d)
15 d.talk()
      • 类方法 @classmethod #只能访问类变量，不能访问实例变量
         1 import os
 2 
 3 class Dog(object):
 4     name = "huazai"
 5     def __init__(self,name):
 6         self.name = name
 7     @classmethod #只能访问类变量，不能访问实例变量
 8     def eat(self):
 9         print("%s is eating %s" %(self.name,'dd'))
10 
11     def talk(self):
12         print("%s is talking"% self.name)
13 
14 
15 d = Dog("ChenRonghua")
16 d.eat()

         

      • 属性方法 @property #把一个方法变成静态属性，调用的时候不需要加（），无法传递参数
         1 import os
 2 
 3 class Dog(object):
 4     '''这个类是描述狗这个对象的'''
 5 
 6     def __init__(self,name):
 7         self.name = name
 8         self.__food = None
 9 
10     @property #把一个方法变成静态属性，调用的时候不需要加（）
11     def eat(self):
12         print("%s is eating %s" %(self.name,self.__food))
13     @eat.setter
14     def eat(self,food):
15         print("set to food:",food)
16         self.__food = food
17     @eat.deleter
18     def eat(self):
19         del self.__food
20         print("删完了")
21 
22 d = Dog("ChenRonghua")
23 d.eat
24 d.eat="baozi"
25 d.eat
26 del d.eat
27 d.eat
    • 类的特殊方法
      • __doc__ #表示类的描述信息，即类开头的注释信息
      • __module__ #表示当前操作系统的对象在哪个模块
      • __class__ #表示当前操作的对象的类是什么
         1 aa.py
 2 
 3 class C:
 4 
 5     def __init__(self):
 6         self.name = 'alex'
 7 
 8 index.py
 9 
10 from lib.aa import C
11 obj = C()
12 print(obj.__module__)  # 输出 lib.aa，即：输出模块
13 print(obj.__class__ )     # 输出 lib.aa.C，即：输出类
      • __init__ #构造方法，通过类创建对象时，自动触发执行
      • __del__ #析构方法，当对象在内存中被释放时，自动触发执行。
      • __call__ #对象后面加（），触发执行。构造方法的执行是由创建对象触发的，即：对象 = 类名() ；而对于 __call__方法的执行是由对象后加括号触发的，即：对象() 或者 类()()
         1 class Foo:
 2     def __init__(self):
 3         pass
 4      
 5     def __call__(self, *args, **kwargs):
 6  
 7         print '__call__'
 8  
 9 obj = Foo() # 执行 __init__
10 obj()       # 执行 __call__
      • __dict__ #查看类或对象中的所有成员。通过类调用，输出的是类里的所有属性，不包括实例属性。通过实例调用，打印所有实例属性，不包括类属性
      • __str__ #如果一个类中定义了__str__方法，那么在打印对象时，默认输出该方法的返回值
      • __getitem__ 、__setitem__、__delitem__ #用于索引操作，如字典，分别表示获取、设置、删除数据
      • __new__、__metaclass__ #https://www.cnblogs.com/alex3714/articles/5213184.html
        • 类的起源与metaclass
           1 def func(self):
 2     print('hello %s' %self.name)
 3 def __init__(self,name,age):
 4     self.name = name
 5     self.age = age
 6 
 7 Foo = type('Foo', (object,), {'talk': func,
 8                        '__init__':__init__})
 9 f = Foo("Chrn",22)
10 f.talk()
11 print(type(Foo))
        • 类的生成 调用 顺序依次是 __new__ --> __init__ --> __call__
    • 反射 #通过字符串映射或修改程序运行时的状态、属性、方法，有以下四种方法：
      • getattr(object, name_str, default=None) #根据字符串name_str去获取object对象里的对应的方法的内存地址
      • hasattr(object,name_str) #判断一个对象object里是否有对应的name_str字符串的方法
      • setattr(object,name_str,new_func) #在实例object中添加名字为name_str的方法new_func函数
      • delattr(object,name_str) #删除对象object中的方法name_str
         1 def bulk(self):
 2     print("%s is yelling...." %self.name)
 3 
 4 class Dog(object):
 5     def __init__(self,name):
 6         self.name = name
 7 
 8     def eat(self,food):
 9         print("%s is eating..."%self.name,food)
10 
11 d = Dog("NiuHanYang")
12 choice = input(">>:").strip()
13 
14 if hasattr(d,choice):  #判断是否有choice输入的这个方法
15     func=getattr(d,choice) #有，则调用类方法
16     func("chenronghua")
17 else:
18     setattr(d,choice,bulk) #给类添加新的方法bulk
19     func = getattr(d, choice) #调用刚刚添加的新方法
20     func(d)

         

  • 异常处理
    • 异常处理结构
       1 try:
 2     # 主代码块
 3     pass
 4 except KeyError,e:
 5     # 异常时，执行该块
 6     pass
 7 else:
 8     # 主代码块执行完，执行该块
 9     pass
10 finally:
11     # 无论异常与否，最终执行该块
12     pass
       1 names = ['alex','jack']
 2 try:
 3     data['name']
 4 except KeyError as e : #每种错入一种处理方法，如果前两种处理方法一样则except (KeyError,IndexError) as e，如果所有错误使用同一种处理方法则except Exception as e
 5     print("没有这个key",e)
 6 except IndexError as e :
 7     print("列表操作错误",e)
 8 except BaseException as e: #除去以上两种之外的其他错误，或者在最后面使用Exception
 9     print("未知错误",e)
10 else:
11     print("一切正常")
12 finally:
13     print("不管有没有错，都执行")
    • 常见错误
      • AttributeError 试图访问一个对象没有的树形，比如foo.x，但是foo没有属性x
      • IOError 输入/输出异常；基本上是无法打开文件
      • ImportError 无法引入模块或包；基本上是路径问题或名称错误
      • IndentationError 语法错误（的子类） ；代码没有正确对齐
      • IndexError 下标索引超出序列边界，比如当x只有三个元素，却试图访问x[5]
      • KeyError 试图访问字典里不存在的键
      • KeyboardInterrupt Ctrl+C被按下
      • NameError 使用一个还未被赋予对象的变量
      • SyntaxError Python代码非法，代码不能编译
      • TypeError 传入对象类型与要求的不符合
      • UnboundLocalError 试图访问一个还未被设置的局部变量，基本上是由于另有一个同名的全局变量，
        导致你以为正在访问它
      • ValueError 传入一个调用者不期望的值，即使值的类型是正确的
    • 自定义异常与主动触发异常
      • 格式
         1 #主动触发异常
 2 try:
 3     raise Exception('错误了。。。')
 4 except Exception,e:
 5     print e
 6     
 7 #自定义异常
 8 class WupeiqiException(Exception):
 9  
10     def __init__(self, msg):
11         self.message = msg
12  
13     def __str__(self):
14         return self.message
15  
16 try:
17     raise WupeiqiException('我的异常')
18 except WupeiqiException,e:
19     print e
      • 实例
        1 class AlexError(Exception):
2     def __init__(self, msg):
3         self.message = msg
4         
5 try:
6     raise AlexError('数据库连不上')
7 except AlexError as e:
8     print(e)

         

  • Scoket开发基础
    • Socket介绍
      • Socket Families(地址簇)
        • socket.AF_UNIX    #unix本机进程间通信
        • socket.AF_INET　#IPV4
        • socket.AF_INET6     #IPV6
      • Socket Types
        • socket.SOCK_STREAM    #for tcp
        • socket.SOCK_DGRAM   #for udp
        • socket.SOCK_RAW   #原始套接字，普通的套接字无法处理ICMP、IGMP等网络报文，而SOCK_RAW可以；其次，SOCK_RAW也可以处理特殊的IPv4报文；此外，利用原始套接字，可以通过IP_HDRINCL套接字选项由用户构造IP头
        • socket.SOCK_RDM   #是一种可靠的UDP形式，即保证交付数据报但不保证顺序。SOCK_RAM用来提供对原始协议的低级访问，在需要执行某些特殊操作时使用，如发送ICMP报文。SOCK_RAM通常仅限于高级用户或管理员运行的程序使用
    • Socket参数介绍
    • 实例
      • 客户端
         1 #客户端
 2 import socket
 3 
 4 client = socket.socket() #声明socket类型，同时生成socket连接对象
 5 client.connect(('localhost',6969))
 6 
 7 while True:
 8     msg = input(">>:").strip()
 9     if len(msg) == 0:continue
10     client.send(msg.encode("utf-8"))
11     data = client.recv(1024) #一次最大接收1024个字节
12     print("recv:",data.decode())
13 
14 client.close()

         

      • 服务端
         1 #服务器端
 2 import socket
 3 server = socket.socket()
 4 server.bind(('localhost',6969)) #绑定要监听端口
 5 server.listen() #监听
 6 
 7 print("我要开始等电话了")
 8 while True:
 9     conn, addr = server.accept()  # 等电话打进来
10     # conn就是客户端连过来而在服务器端为其生成的一个连接实例
11     print(conn, addr)
12     print("电话来了")
13     while True:
14         data = conn.recv(1024)
15         print("recv:",data)
16         if not data:  #接收到的数据为空则断开
17             print("client has lost...")
18             break
19         conn.send(data.upper())
20 
21 server.close()

         

posted @ 2019-06-09 10:58  飞琼君  阅读(124)  评论(0)    收藏  举报