首页 > 代码库 > Python面向对象进阶

Python面向对象进阶

面向对象的高级语法:

    静态方法

   通过@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 = http://www.mamicode.com/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 = http://www.mamicode.com/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 = http://www.mamicode.com/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 = http://www.mamicode.com/client.recv(1024)
12     print("来自服务器:",data)
13 
14 client.close()

 

Python面向对象进阶