Python面向对象进阶

Posted 2020-08-27

面向对象的高级语法：

    静态方法

   通过@staticmethod装饰器即可把其装饰的方法变为一个静态方法，什么是静态方法呢？

其实不难理解，普通的方法，可以在实例化后直接调用，并且在方法里可以通过self.调用实例变量或类变量，但静态方法是不可以访问实例变量或类变量的，一个不能访问实例变量和

类变量的方法，其实相当于跟类本身已经没什么关系了，它与类唯一的关联就是需要通过类名来调用这个方法

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

 

    类方法

类方法通过@classmethod装饰器实现，类方法和普通方法的区别是， 类方法只能访问类变量，不能访问实例变量

 1 class Dog(object):
 2     name = "paul"
 3     def __init__(self,name):
 4         self.name = name
 5 
 6     @classmethod   #类方法
 7     def eat(self):
 8         print("%s is eating"%(self.name))
 9 
10 d = Dog("alex")
11 d.eat()

这里的类方法，不能够访问alex，只能访问paul！

    属性方法（有点难理解）

 把一个方法变成一个静态属性，不能通过加（）调用

 1 class Dog(object):
 2 
 3     def __init__(self,name):
 4         self.name = name
 5 
 6     @property  #属性方法
 7     def eat(self):
 8         print("%s is eating"%(self.name))
 9 
10 d = Dog("alex")
11 d.eat

 

 1 class Flight(object):
 2     def __init__(self,name):
 3         self.flight_name = name
 4 
 5 
 6     def checking_status(self):
 7         print("checking flight %s status " % self.flight_name)
 8         return  1
 9 
10     @property  #属性方法
11     def flight_status(self):
12         status = self.checking_status()  #先检查状态
13         if status == 0 :
14             print("flight got canceled...")
15         elif status == 1 :
16             print("flight is arrived...")
17         elif status == 2:
18             print("flight has departured already...")
19         else:
20             print("cannot confirm the flight status...,please check later")
21 
22 
23 f = Flight("CA980")
24 f.flight_status

类的特殊成员方法

 1. __doc__　　表示类的描述信息

1 class Foo: 
2     """ 描述类信息，这是用于看片的神奇 """
3   
4     def func(self): 
5         pass
6   
7 print Foo.__doc__ 
8 #输出：类的描述信息 

2. __module__ 和  __class__ 

     __module__ 表示当前操作的对象在那个模块

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

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

4.__del__

　析构方法，当对象在内存中被释放时，自动触发执行。

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

注：构造方法的执行是由创建对象触发的，即：对象 = 类名() ；而对于 __call__ 方法的执行是由对象后加括号触发的，即：对象() 或者 类()()

 1 class Foo:
 2     def __init__(self):
 3         pass
 4 
 5     def __call__(self, *args, **kwargs):
 6         print("we are talking")
 7         ‘__call__‘
 8 
 9 obj = Foo()  # 执行 __init__
10 obj()  # 执行 __call

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

 1 class Province:
 2     country = ‘China‘
 3 
 4     def __init__(self, name, count):
 5         self.name = name
 6         self.count = count
 7 
 8     def func(self, *args, **kwargs):
 9         print
10         ‘func‘
11 print(Province.__dict__)#获取类的成员，即，静态字段、方法
12 
13 obj1 = Province(‘HeBei‘,10000)#获取obj1的成员
14 print (obj1.__dict__)

7.__str__ 如果一个类中定义了__str__方法，那么在打印对象时，默认输出该方法的返回值。

1 class Foo:
2     def __str__(self):
3         return ‘alex li‘
4 
5 obj = Foo()
6 print(obj)# 输出：alex li

8.__getitem__、__setitem__、__delitem__

用于索引操作，如字典。以上分别表示获取、设置、删除数据（相当于把类做成了字典）

 1 class Foo(object):
 2     def __getitem__(self, key):
 3         print(‘__getitem__‘, key)
 4 
 5     def __setitem__(self, key, value):
 6         print(‘__setitem__‘, key, value)
 7 
 8     def __delitem__(self, key):
 9         print(‘__delitem__‘, key)
10 
11 obj = Foo()
12 result = obj[‘k1‘]  # 自动触发执行 __getitem__
13 obj[‘k2‘] = ‘alex‘  # 自动触发执行 __setitem__
14 del obj[‘k1‘]

9. __new__ \\ __metaclass__

 

So ，孩子记住，类是由type 类实例化产生

类的生成 调用 顺序依次是 __new__ --> __call__ --> __init__

 

 new 是用来创建实例的，大多数情况，不需要我们写。

 

反射

 

通过字符串映射或修改程序运行时的状态、属性、方法, 有以下4个方法

hasattr（obj，name_str）：判断object中有没有一个name字符串对应的方法或属性

getattr（obj，name_str）：根据字符串去获取obj对象里对应的方法的内存地址

setattr（obj，“y”，z）通过字符串设置新的属性

delsttr（x，y）删除一个对应的属性

 1 class Foo(object):
 2     def __init__(self):
 3         self.name = ‘wupeiqi‘
 4 
 5     def func(self):
 6         return ‘func‘
 7 
 8 obj = Foo()
 9 
10 # #### 检查是否含有成员 ####
11 hasattr(obj, ‘name‘)
12 hasattr(obj, ‘func‘)
13 
14 # #### 获取成员 ####
15 getattr(obj, ‘name‘)
16 getattr(obj, ‘func‘)
17 
18 # #### 设置成员 ####
19 setattr(obj, ‘age‘, 18)
20 setattr(obj, ‘show‘, lambda num: num + 1)
21 
22 # #### 删除成员 ####
23 delattr(obj, ‘name‘)
24 delattr(obj, ‘func‘)

异常处理

 

参考 http://www.cnblogs.com/wupeiqi/articles/5017742.html   

 

Socket 编程

http：网站

smtp：邮件

dns：把域名解析成ip地址

ftp：下载，上传文件

ssh

snmp：简单网络通信

icmp：ping包，测试网络通不通

dhcp

 

OSI七层模型：

应用

表示

会话

传输

网络

数据链路：mac地址16进制

物理层

 

通信协议：

TCP\\IP:三次握手，四次断开吗，安全数据的发送

UDP：不安全的数据发送，不关心B的状态，直接发，可能会丢包，流媒体应该是UDP

 

SOCKET套接字的简单通信

 

 1 import socket#服务器端
 2 server = socket.socket()
 3 server.bind((‘localhost‘,6969)) #绑定要监听的端口
 4 
 5 server.listen(6969)
 6 print("waiting for phone")
 7 conn,addr = server.accept()  #等电话打进来
 8 print(conn,addr)#conn就是客户端连过来而在服务器为其生成的一个连接实例
 9 
10 data = conn.recv(1024)
11 print("recv:",data)
12 conn.send(data.upper())
13 
14 server.close()

 

1 import socket#客户端
2 client = socket.socket()  #申明socket类型，同事生成socket连接对象
3 client.connect((‘localhost‘,6969))
4 client.send(b"hello world")
5 data = client.recv(1024)
6 print("recv:",data)
7 client.close()

 

实现多次交互，并且提供多个用户进行客户端的访问

 

 1 import socket
 2 
 3 server = socket.socket()  # 获得socket实例
 4 
 5 server.bind(("localhost", 8))  # 绑定ip port
 6 server.listen(8)  # 开始监听，最大允许连接为8
 7 
 8 while True:  # 第一层loop
 9     print("等待客户端的连接...")
10     conn, addr = server.accept()  # 接受并建立与客户端的连接,程序在此处开始阻塞,只到有客户端连接进来...
11     print("新连接:", addr)
12     while True:
13 
14         data = conn.recv(1024)
15         if not data:
16             print("客户端断开了...")
17             break  # 这里断开就会再次回到第一次外层的loop
18         print("收到消息:", data)
19         conn.send(data.upper())
20 
21 server.close()

 

 

 

 1 import socket
 2 
 3 client = socket.socket()
 4 
 5 client.connect(("localhost",98))
 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)
12     print("来自服务器:",data)
13 
14 client.close()