NO.7：自学python之路------类的方法、异常处理、socket网络编程

引言

　　我visual studio 2017就算体积巨大、启动巨慢、功能简陋也不会安装PyCharm的，嘿呀，真香。好吧，为了实现socket网络编程，更换了软件。

正文

静态方法

　　只是在名义上归类管理，实际上在静态方法里访问不了类或实例中的任何属性。例子。

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

    @staticmethod#静态方法
    def name(self):
        print('名字是%s'%(self.name))

a = Student('二狗')
a.name()#报错，因为静态方法无法访问实例中的属性

View Code

类方法

　　与静态方法类似，只能访问类变量，不能访问实例变量。

class Student(object):
    name = '二狗'
    def __init__(self,name):
        self.name = name
    @classmethod
    def name(self):
        print('名字是%s'%(name))
        print('名字是%s'%(self.name))

a = Student('蛋蛋')
a.name()#可以打印类中的名字，之后报错

View Code

属性方法

　　把一个方法变成静态属性。例子。

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

    @property
    def logging(self):
        print('%s注册成功'%(self.name))

a = Student('二狗')
a.logging #无需加括号直接运行

View Code

　　但是，这样无法为属性赋值，也无法删除。为了能够赋值和删除，特增加setter和delte方法。例子。

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

    @property
    def logging(self):
        print('%s注册成功'%(self.__newname))
    @logging.setter
    def logging(self,name):
        self.__newname = name
    @logging.deleter
    def logging(self):
        del self.__newname
        print('删除')

a = Student('二狗')
a.logging = '蛋蛋' # 无需加括号直接运行
del a.logging # 删除

View Code

类的特殊方法

　　__doc__方法，可以返回类的描述。例子。

 

class Student(object):
    '''用于测试'''
    def __init__(self, name):
        self.name = name

a = Student('二狗')
print(a.__doc__)#打印出：用于测试

View Code

 

　　__module__方法，可以返回类所在的模块。例子。

class Student(object):
    '''用于测试'''
    def __init__(self, name):
        self.name = name

a = Student('二狗')
print(a.__module__)#打印：__main__

View Code

　　__class__方法，可以返回类和类所在的模块。例子。

class Student(object):
    '''用于测试'''
    def __init__(self, name):
        self.name = name

a = Student('二狗')
print(a.__class__)#打印 ： <class '__main__.Student'>

View Code

　　__call__方法，在类中定义后，可直接由类名() + ()直接运行，或者由对象+()运行。例子。

class Student(object):
    '''用于测试'''
    def __init__(self, name):
        self.name = name
    def __call__(self):
        print('in the call')

Student('二狗')()# 打印：in the call
a = Student('二狗')
a()# 打印： in the call

View Code

　　__dict__方法，可以查看类：打印类中所有的属性，不包括实例属性。或者查看对象：打印对象所有实例属性，不包括类属性。例子。

class Student(object):
    '''用于测试'''
    def __init__(self, name):
        self.name = name
    def __call__(self):
        print('in the call')

print(Student.__dict__)#打印出了所有类属性
a = Student('二狗')
print(a.__dict__)#只打印：{'name': '二狗'}

View Code

　　__str__方法，当类中定义了该方法时，打印对象时，默认打印该方法的返回值。例子。

class Student(object):
    '''用于测试'''
    def __init__(self, name):
        self.name = name
    def __str__(self):
        return 'in the str'

a = Student('二狗')
print(a)#打印：in the str

View Code

　　使类字典化：__getitem__方法，__setitem__方法，__delitem__方法。例子。

class Student(object):
    '''用于测试'''
    def __init__(self):
        self.data = {}
    def __getitem__(self, key):
        print('__getitem__', key)
        return self.data.get(key)
    def __setitem__(self, key, value):
        print('__setitem__', key, value)
        self.data[key] = value
    def __delitem__(self, key):
        print('__delitem__', key)

a = Student() # 实例化
a['name'] = '二狗' # 触发__setitem__
print(a['name']) # 触发__getitem__
del a['name'] # 触发__delitem__

View Code

类的起源

　　在Python中，一切皆对象，所以类的创建过程背后，也是通过执行某种类的创建办法创建的。通过打印类的type可以发现，类来源于type。所以存在另外一种创建类的方法。例子。

def func(self):
    print('hello %s'%(self.name))
def __init__(self,name):
    self.name = name
Foo = type('Foo',(object,),{'talk':func, '__init__':__init__})
f = Foo('二狗')
f.talk()

View Code

　　那么type类的起源又是什么呢？这个可以从下面例子中得到。

class MyType(type):
    '''创建自己的type'''
    def __init__(self,what,bases=None,dict=None):
        print('MyType init')
        super(MyType,self).__init__(what,bases,dict)

    def __call__(self, *args, **kwargs):
        print('MyType call')#自定义创建过程
        obj = self.__new__(self,*args,**kwargs)
        self.__init__(obj,*args,**kwargs)

class Foo(object):
    __metaclass__ = MyType

    def __init__(self,name):
        self.name = name
        print('init')

    def __new__(cls,*args,**kwargs):
        '''类中自带的方法'''
        print('new')
        return object.__new__(cls)

View Code

　　例子中，首先运行MyType中的__init__初始化，之后进入__call__用于创建类的__new__，开辟出self的内存空间。之后进入类中的__new__用于调用类中的init。

异常处理

　　在编程过程中往往会遇到异常，影响后续程序的运行。通过处理异常可以保证程序在遇到异常后任能够将后续内容执行完毕。方便程序员调试。处理异常的过程如下。例子。

name = ['lala','haha']
data = {}
try:
    name[3]
    data['name']
except KeyError as e:#将没有Key的错误用e获取
    print('没有这个key',e)
except (IndexError, KeyError) as e:#将错误用e获取,括号括起来可同时处理多个异常
    print('列表操作错误',e)
except Exception as e:#可以与之前配合使用，这个用于判断未知错误
    print('未知错误',e)
else:
    print('一切正常')
finally: # 不管有没有错，都会执行
    print('最后一步')

View Code

　　当然，异常也可以自定义，通过自己预先考虑创建一些异常。自定义异常例子。

class NewException(Exception):
    def __init__(self,msg):
        self.message = msg
    def __str__(self): # 默认构建，可以不写
        return self.message

try:
    raise NewException('异常描述')#触发异常方法
except NewException as e:
    print(e)

View Code

socket网络编程

　　这个主要就是实现服务器端与客户端之间的信息交流。具体可以通过例子来学习。

　　服务器端：

# 服务器端
import socket
server = socket.socket()  # 声明socket类型，同时生成socket连接对象
server.bind(('localhost', 9998))  # 绑定端口
server.listen()  # 监听
print('开始监听')
conn, addr = server.accept()  # 等电话打进来
# conn客户端连过来而在服务器端为其生成的连接实例链接，端口只能同时和1个人通话
print('听到')
while True:
    data = conn.recv(1024)
    if not data:
        print("clinet has lost")
        break
    print('收到:', data)
    conn.send(data.upper()) #转为大写后传回
server.close()

View Code

　　客户机端：

import socket

client = socket.socket()  # 声明socket类型，同时生成socket连接对象
client.connect(('localhost', 9998))
while True:
    msg = input('>>').strip()
    if len(msg):
        print('不能为空')
        continue
    client.send(msg.encode('utf-8'))  # sendall循环发送全部文件
    data = client.recv(1024)
    print('recv:', data.decode())

View Code