静态方法，类方法，属性方法及其他特殊方法,类的创建过程，反射，异常，socket

静态方法：无法访问类属性和实例属性

类方法：无法访问到实例属性

属性方法：（将一个方法让用户像调用属性一样进行调用）

# Author:zylong

class MethodClass:

    @staticmethod#静态方法
    def staticMethod(self):
        print("name")

    @classmethod
    def classMethod(self):
        pass

    #这个age属性不能直接方法
    def __init__(self,name,age):
        self.name = name
        self.__age = age
    #属性方法

    @property
    def getAge(self):
        return self.__age
    #通过这样的方式，设置私有属性
    @getAge.setter
    def setAge(self,age):
        self.__age = age

#在外界调用的时候，用户是以属性的方式访问
a = MethodClass("zhang",20)

print(a.getAge)

 

 

类中的其他方法，了解：

aa = {}

#实现这样的方式，可以将类当成字典，进行使用
    def __getitem__(self, item):
        return self.aa[item]

    def __setitem__(self, key, value):
        self.aa[key] = value


a = MethodClass("zhang",20)
#这样就是以字典的方式进行设置和访问。这里a是类，不是字典
a["name"] = "yu"
print(a["name"])

　　

def __call__(self, *args, **kwargs):
    print("嗲用")

实例化类后，a = MethodClass("zhang",20) 再用 a()进行调用


类的实例过程 ，python中一切都是对象，类也是对象，类是type的对象，这里使用type方式来实例一个类

def talk(self):
    print("%s is talk"%self.name)
aa = type("NewClass",(object,),{"name":"zhang","age":20,"fee":talk})

#这里调用的时候必须把自己传进去
aa.fee(aa)

 

类的实例过程：

class ClassProcess(object):

    def __init__(self,name,age):
        print("init")
        pass

    def __new__(cls, *args, **kwargs):
        print("new")
        return object.__new__(cls)

cp = ClassProcess("zhang",20)
#运行结果是：
"""
new
init
"""
可以看出，先运行 new 在运行init方法实例类

 

 

反射：

# Author:zylong

class RefClass:
    def __init__(self,name):
        self.name = name
    pass

#这个类是空类，使用反射设置属性

msg = input("》》:")
ref = RefClass("zhang")
#属性
# if hasattr(ref,msg):
#     aa = getattr(ref,msg)
#     print(aa)
# else:
#     val = input(">>value:")
#     setattr(ref,msg,val)
#     aa = getattr(ref, msg)
#     print(aa)

#方法
"""
使用反射添加方法的时候，定义的方法，必须带self参数
"""
def talk(self,aa):
    print("%s is talk "%self.name,aa)

if hasattr(ref,msg):
    aa = getattr(ref,msg)
    print(aa)
else:
    # val = input(">>value:")
    setattr(ref,msg,talk)
    aa = getattr(ref, msg)
    print(aa)
    aa(ref,"123")

 

异常和自定异常：

# Author:zylong
name = [12,212]

age = {}

try:
    # print(name[3])
    age["key"]
except IndexError as e:
    """
    #如果多个异常可以写多个except
    也可以使用 
    except(IndexError,KeyError) as e
    """
    print(e)
except Exception as e:
    """
    exception 是所有类的父类，这个不建议使用
    """
    print(e)
else:
    print("没有出错")
finally:
    print("无论错不错都执行")


class MyError(Exception):

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

    #这个重不重写都可以
    # def __str__(self):
    #     return self.msg

try:
    raise MyError("自定义异常")
except MyError as e:
    print(e)

 

 

socket:

按理解，写的伪代码：

要实现通信，肯定要有一个客户端和一个服务端

应该先有服务端，要不客户端给谁发送数据呢

服务端：

　　服务端不是所有的客户端发的请求都接受，所以服务端需要监听 某个或某些客户端

　　1.通信需要先规定，是以什么样的协议进行传递数据

　　2.鉴定客户端

　　3.接受客户端发来的数据

　　4.发送数据给客户端

　　5.关闭服务端

客户端：

　　1.先规定协议，这里要和服务端一致

　　2.创建连接，（ip地址和端口）

　　3.发送数据

　　4.接受服务端数据

　　5.关闭连接

 

 

server:

# Author:zylong

import socket

#family=AF_INET, type=SOCK_STREAM 这个是默认参数 AF_INET 这个是ip4 tcp协议
server = socket.socket()

server.bind(("0.0.0.0",6666))
server.listen()
"""
coon,addr = server.accept()#这个就相当于与一个客户端创建连接
while True:
    data = coon.recv(1024)
    coon.sendall(data.upper())
"""
#这样的服务职能接一个数据就端口
"""
coon,addr = server.accept()#这个就相当于与一个客户端创建连接
while True:
    data = coon.recv(1024)
    coon.sendall(data.upper())
server.close()

这样的会有一个问题，只能与一cl个客户端连接，当那个客户端断了后，服务端就断了所以连接需要多个，
当一个客户端断后，获取下一个连接

"""
while True:
    coon,addr = server.accept()#这个就相当于与一个客户端创建连接
    while True:
        data = coon.recv(1024)
        if not data:break
        coon.sendall(data.upper())

server.close()

 

client:

# Author:zylong
import socket

client = socket.socket()

client.connect(("localhost",6666))
while True:
    msg = input(">>:")
    client.send(msg.encode("utf-8"))
    if not msg:break
    data = client.recv(1024)
    print(data.decode("utf-8"))
client.close()

 

这里如果在windows中，当关闭客户端时候，服务端自动端口，所以在linux中进行尝试，多客户端连接