Day7 - Python基础7 面向对象编程进阶 --转自金角大王

时间  2019-12-04
标签 day7 day python 基础 面向对象 编程 进阶 大王 栏目 Python 繁體版
原文   原文链接

本节内容：html

  • 面向对象高级语法部分
    • 经典类vs新式类　　
    • 静态方法、类方法、属性方法
    • 类的特殊方法
    • 反射
  • 异常处理
  • Socket开发基础
  • 做业：开发一个支持多用户在线的FTP程序

　　

面向对象高级语法部分

经典类vs新式类

把下面代码用python2 和python3都执行一下python

?
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
#_*_coding:utf-8_*_
 
 
class A:
     def __init__( self ):
         self .n = 'A'
 
class B(A):
     # def __init__(self):
     #     self.n = 'B'
     pass
 
class C(A):
     def __init__( self ):
         self .n = 'C'
 
class D(B,C):
     # def __init__(self):
     #     self.n = 'D'
     pass
 
obj = D()
 
print (obj.n)

classical vs new style：程序员

  • 经典类：深度优先
  • 新式类：广度优先
  • super()用法

 

抽象接口

?
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
import abc
 
class Alert( object ):
     '''报警基类'''
     __metaclass__ = abc.ABCMeta
 
     @abc .abstractmethod
     def send( self ):
         '''报警消息发送接口'''
         pass
 
 
 
class MailAlert(Alert):
     pass
 
 
m = MailAlert()
m.send()

上面的代码仅在py2里有效，python3里怎么实现呢？编程

　　

 

 

 

　　

静态方法

经过@staticmethod装饰器便可把其装饰的方法变为一个静态方法，什么是静态方法呢？其实不难理解，普通的方法，能够在实例化后直接调用，而且在方法里能够经过self.调用实例变量或类变量，但静态方法是不能够访问实例变量或类变量的，一个不能访问实例变量和类变量的方法，其实至关于跟类自己已经没什么关系了，它与类惟一的关联就是须要经过类名来调用这个方法ide

?
1
2
3
4
5
6
7
8
9
10
11
12
13
class Dog( object ):
 
     def __init__( self ,name):
         self .name = name
 
     @staticmethod #把eat方法变为静态方法
     def eat( self ):
         print ( "%s is eating" % self .name)
 
 
 
d = Dog( "ChenRonghua" )
d.eat()

上面的调用会出如下错误，说是eat须要一个self参数，但调用时却没有传递，没错，当eat变成静态方法后，再经过实例调用时就不会自动把实例自己看成一个参数传给self了。函数

?
1
2
3
4
Traceback (most recent call last):
   File "/Users/jieli/PycharmProjects/python基础/自动化day7面向对象高级/静态方法.py" , line 17 , in <module>
     d.eat()
TypeError: eat() missing 1 required positional argument: 'self'

想让上面的代码能够正常工做有两种办法ui

1. 调用时主动传递实例自己给eat方法，即d.eat(d) 加密

2. 在eat方法中去掉self参数，但这也意味着，在eat中不能经过self.调用实例中的其它变量了spa

复制代码
复制代码 
 1 class Dog(object):  2  3 def __init__(self,name):  4 self.name = name  5  6  @staticmethod  7 def eat():  8 print(" is eating")  9 10 11 12 d = Dog("ChenRonghua") 13 d.eat()
复制代码
复制代码

 

类方法　　

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

?
1
2
3
4
5
6
7
8
9
10
11
12
class Dog( object ):
     def __init__( self ,name):
         self .name = name
 
     @classmethod
     def eat( self ):
         print ( "%s is eating" % self .name)
 
 
 
d = Dog( "ChenRonghua" )
d.eat()

执行报错以下，说Dog没有name属性，由于name是个实例变量，类方法是不能访问实例变量的

?
1
2
3
4
5
6
Traceback (most recent call last):
   File "/Users/jieli/PycharmProjects/python基础/自动化day7面向对象高级/类方法.py" , line 16 , in <module>
     d.eat()
   File "/Users/jieli/PycharmProjects/python基础/自动化day7面向对象高级/类方法.py" , line 11 , in eat
     print ( "%s is eating" % self .name)
AttributeError: type object 'Dog' has no attribute 'name'

此时能够定义一个类变量，也叫name,看下执行效果

?
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
class Dog( object ):
     name = "我是类变量"
     def __init__( self ,name):
         self .name = name
 
     @classmethod
     def eat( self ):
         print ( "%s is eating" % self .name)
 
 
 
d = Dog( "ChenRonghua" )
d.eat()
 
 
#执行结果
 
我是类变量 is eating

 

属性方法　　

属性方法的做用就是经过@property把一个方法变成一个静态属性

?
1
2
3
4
5
6
7
8
9
10
11
12
class Dog( object ):
 
     def __init__( self ,name):
         self .name = name
 
     @property
     def eat( self ):
         print ( " %s is eating" % self .name)
 
 
d = Dog( "ChenRonghua" )
d.eat()

调用会出如下错误， 说NoneType is not callable, 由于eat此时已经变成一个静态属性了， 不是方法了， 想调用已经不须要加()号了，直接d.eat就能够了

?
1
2
3
4
5
Traceback (most recent call last):
  ChenRonghua is eating
   File "/Users/jieli/PycharmProjects/python基础/自动化day7面向对象高级/属性方法.py" , line 16 , in <module>
     d.eat()
TypeError: 'NoneType' object is not callable

正常调用以下

?
1
2
3
4
5
d = Dog( "ChenRonghua" )
d.eat
 
输出
  ChenRonghua is eating

好吧，把一个方法变成静态属性有什么卵用呢？既然想要静态变量，那直接定义成一个静态变量不就得了么？well, 之后你会需到不少场景是不能简单经过 定义 静态属性来实现的， 好比 ，你想知道一个航班当前的状态，是到达了、延迟了、取消了、仍是已经飞走了， 想知道这种状态你必须经历如下几步:

1. 链接航空公司API查询

2. 对查询结果进行解析 

3. 返回结果给你的用户

所以这个status属性的值是一系列动做后才获得的结果，因此你每次调用时，其实它都要通过一系列的动做才返回你结果，但这些动做过程不须要用户关心， 用户只须要调用这个属性就能够，明白 了么？

复制代码 
class Flight(object): def __init__(self,name): self.flight_name = name def checking_status(self): print("checking flight %s status " % self.flight_name) return 1 @property def flight_status(self): status = self.checking_status() if status == 0 : print("flight got canceled...") elif status == 1 : print("flight is arrived...") elif status == 2: print("flight has departured already...") else: print("cannot confirm the flight status...,please check later") f = Flight("CA980") f.flight_status
复制代码

cool , 那如今我只能查询航班状态， 既然这个flight_status已是个属性了， 那我可否给它赋值呢？试试吧

?
1
2
3
f = Flight( "CA980" )
f.flight_status
f.flight_status =  2

输出， 说不能更改这个属性，我擦。。。。，怎么办怎么办。。。 

?
1
2
3
4
5
6
checking flight CA980 status
flight is arrived...
Traceback (most recent call last):
   File "/Users/jieli/PycharmProjects/python基础/自动化day7面向对象高级/属性方法.py" , line 58 , in <module>
     f.flight_status =  2
AttributeError: can't set attribute

固然能够改， 不过须要经过@proerty.setter装饰器再装饰一下，此时 你须要写一个新方法， 对这个flight_status进行更改。

复制代码 
class Flight(object): def __init__(self,name): self.flight_name = name def checking_status(self): print("checking flight %s status " % self.flight_name) return 1 @property def flight_status(self): status = self.checking_status() if status == 0 : print("flight got canceled...") elif status == 1 : print("flight is arrived...") elif status == 2: print("flight has departured already...") else: print("cannot confirm the flight status...,please check later") @flight_status.setter #修改 def flight_status(self,status): status_dic = { 0 : "canceled", 1 :"arrived", 2 : "departured" } print("\033[31;1mHas changed the flight status to \033[0m",status_dic.get(status) ) @flight_status.deleter #删除 def flight_status(self): print("status got removed...") f = Flight("CA980") f.flight_status f.flight_status = 2 #触发@flight_status.setter del f.flight_status #触发@flight_status.deleter
复制代码

注意以上代码里还写了一个@flight_status.deleter, 是容许能够将这个属性删除 

 

类的特殊成员方法

1. __doc__　　表示类的描述信息

2. __module__ 和  __class__ 

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

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

class C: def __init__(self): self.name = 'wupeiqi'
from lib.aa import C obj = C() print obj.__module__ # 输出 lib.aa，即：输出模块 print obj.__class__ # 输出 lib.aa.C，即：输出类

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

4.__del__

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

注：此方法通常无须定义，由于Python是一门高级语言，程序员在使用时无需关心内存的分配和释放，由于此工做都是交给Python解释器来执行，因此，析构函数的调用是由解释器在进行垃圾回收时自动触发执行的

　　

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

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

6. __dict__ 查看类或对象中的全部成员 　　

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

8.__getitem__、__setitem__、__delitem__

用于索引操做，如字典。以上分别表示获取、设置、删除数据

9. __new__ \ __metaclass__

?
1
2
3
4
5
6
7
8
class Foo( object ):
 
 
     def __init__( self ,name):
         self .name = name
 
 
f = Foo( "alex" )

上述代码中，obj 是经过 Foo 类实例化的对象，其实，不只 obj 是一个对象，Foo类自己也是一个对象，由于在Python中一切事物都是对象。

若是按照一切事物都是对象的理论：obj对象是经过执行Foo类的构造方法建立，那么Foo类对象应该也是经过执行某个类的 构造方法 建立。

?
1
2
print type (f) # 输出：<class '__main__.Foo'>     表示，obj 对象由Foo类建立
print type (Foo) # 输出：<type 'type'>              表示，Foo类对象由 type 类建立

因此，f对象是Foo类的一个实例，Foo类对象是 type 类的一个实例，即：Foo类对象 是经过type类的构造方法建立。

那么，建立类就能够有两种方式：

a). 普通方式 

?
1
2
3
4
class Foo( object ):
  
     def func( self ):
         print 'hello alex'

b). 特殊方式

?
1
2
3
4
5
6
7
def func( self ):
     print 'hello wupeiqi'
  
Foo = type ( 'Foo' ,( object ,), { 'func' : func})
#type第一个参数：类名
#type第二个参数：当前类的基类
#type第三个参数：类的成员
复制代码 
def func(self): print("hello %s"%self.name) def __init__(self,name,age): self.name = name self.age = age Foo = type('Foo',(object,),{'func':func,'__init__':__init__}) f = Foo("jack",22) f.func()
复制代码

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

那么问题来了，类默认是由 type 类实例化产生，type类中如何实现的建立类？类又是如何建立对象？

答：类中有一个属性 __metaclass__，其用来表示该类由 谁 来实例化建立，因此，咱们能够为 __metaclass__ 设置一个type类的派生类，从而查看 类 建立的过程。

 

复制代码 
 1 class MyType(type):  2 def __init__(self,*args,**kwargs):  3  4 print("Mytype __init__",*args,**kwargs)  5  6 def __call__(self, *args, **kwargs):  7 print("Mytype __call__", *args, **kwargs)  8 obj = self.__new__(self)  9 print("obj ",obj,*args, **kwargs) 10 print(self) 11 self.__init__(obj,*args, **kwargs) 12 return obj 13 14 def __new__(cls, *args, **kwargs): 15 print("Mytype __new__",*args,**kwargs) 16 return type.__new__(cls, *args, **kwargs) 17 18 print('here...') 19 class Foo(object,metaclass=MyType): 20 21 22 def __init__(self,name): 23 self.name = name 24 25 print("Foo __init__") 26 27 def __new__(cls, *args, **kwargs): 28 print("Foo __new__",cls, *args, **kwargs) 29 return object.__new__(cls) 30 31 f = Foo("Alex") 32 print("f",f) 33 print("fname",f.name)
复制代码

 

 

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

 metaclass 详解文章：http://stackoverflow.com/questions/100003/what-is-a-metaclass-in-python 得票最高那个答案写的很是好

 

反射

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

复制代码 
def getattr(object, name, default=None): # known special case of getattr """ getattr(object, name[, default]) -> value Get a named attribute from an object; getattr(x, 'y') is equivalent to x.y. When a default argument is given, it is returned when the attribute doesn't exist; without it, an exception is raised in that case. """ pass
复制代码 
判断object中有没有一个name字符串对应的方法或属性
def setattr(x, y, v): # real signature unknown; restored from __doc__ """ Sets the named attribute on the given object to the specified value. setattr(x, 'y', v) is equivalent to ``x.y = v''
def delattr(x, y): # real signature unknown; restored from __doc__ """ Deletes the named attribute from the given object. delattr(x, 'y') is equivalent to ``del x.y'' """
复制代码 
class Foo(object): def __init__(self): self.name = 'wupeiqi' def func(self): return 'func' obj = Foo() # #### 检查是否含有成员 #### hasattr(obj, 'name') hasattr(obj, 'func') # #### 获取成员 #### getattr(obj, 'name') getattr(obj, 'func') # #### 设置成员 #### setattr(obj, 'age', 18) setattr(obj, 'show', lambda num: num + 1) # #### 删除成员 #### delattr(obj, 'name') delattr(obj, 'func')
复制代码

 

 

动态导入模块

 

 

?
1
2
3
4
import importlib
 
__import__ ( 'import_lib.metaclass' ) #这是解释器本身内部用的
#importlib.import_module('import_lib.metaclass') #与上面这句效果同样，官方建议用这个

 

　　

异常处理 

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

 

 

Socket 编程

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

 

 

做业：开发一个支持多用户在线的FTP程序

 

要求：

 

  1. 用户加密认证
  2. 容许同时多用户登陆
  3. 每一个用户有本身的家目录 ，且只能访问本身的家目录
  4. 对用户进行磁盘配额，每一个用户的可用空间不一样
  5. 容许用户在ftp server上随意切换目录
  6. 容许用户查看当前目录下文件
  7. 容许上传和下载文件，保证文件一致性
  8. 文件传输过程当中显示进度条
  9. 附加功能：支持文件的断点续传
相关文章
相关标签/搜索
每日一句
    每一个你不满意的现在，都有一个你没有努力的曾经。
本站公众号
   欢迎关注本站公众号,获取更多信息
联系我们 最近搜索 最新文章 沪ICP备13005482号-10 MyBatis教程 SQL 教程 MySQL教程 Java 教程 Thymeleaf 教程 Hibernate教程 Spring教程 Redis教程