Python全栈开发，Day8

本章内容

1. 经典类与新式类
2. 静态方法、类方法、属性方法
3. 类的特殊成员方法
4. 反射
5. 异常处理

 一、经典类与新式类

Python中分为经典类和新式类：

　　　经典类：

　　　　　　class A（）：

　　　新式类：

　　　　　　class A（object）：

经典类和新式类的区别就是，在声明类的时候，新式类需要加上object关键字。

Python的类可以继承多个类，Java和C#中则只能继承一个类

Python的类如果继承了多个类，那么其寻找方法有两种：

　　当类是经典类时，多继承情况下，会按照深度优先（纵向）方式查找

　　当类是新式类时，多继承情况下，会按照广度优先（横向）方式查找

 在python3.x 和 python2.x中运行以下代码：

#！/usr/bin/env python
# -*- coding:utf-8 -*-
# Author：Lyon

class A:
    def __init__(self):
        self.n = 'A'
        print("In the A")

class B(A):
    def __init__(self):
        self.n = 'B'
        print("In the B")

class C(A):
    def __init__(self):
        self.n = 'C'
        print("In the C")

class D(B,C):
    # def __init__(self):
    #     self.n = 'D'
        print("In the D")
#创建一个实例obj1，注释掉D（）中的构造方法之后，继承B、C中的一个看结果
obj1 = D()
#打印obj1中的n
print(obj1.n)
#用B（）来做比较
obj2 = B()
#打印obj2中的n
print(obj2.n)


#输出：In the D
#      In the B
#      B  #这里我们发现D（）中没有构造方法所以往B、C中找，为什么继承了B（）？
#      In the B
#      B

在python2.x和3.x中：

　　Python 2.x 中默认都是经典类，只有显示继承了object才是新式类

　　Python 3.x 中默认都是新式类，不必显示的继承object

class A():
    def __init__(self):
        pass
    def save(self):
        print "This is from A"
class B(A):
    def __init__(self):
        pass
class C(A):
    def __init__(self):
        pass
    def save(self):
        print  "This is from C"
class D(B,C):
    def __init__(self):
        pass
fun =  D()
fun.save()

#经典类的答案： This is from A
#新式类的答案： This is from C

 

super的用法：

　　在python2中没有此用法，只有在3中才有。此方法大大降低了代码的维护量。

　　语法：super（B，self）.__init__（）

　　

#！/usr/bin/env python
# -*- coding:utf-8 -*-
# Author：Lyon
#调用基类方法
 
#  一、 明确指定
class P():
    print("In the P")
  
class C(P):
    def __init__(self):
        P.__init__(self)
        print("In the C")
 
c = C()

# 二、 super（）方法
 
class P():
    print("In the P")
 
class C():
    def __init__(self):
        super(C,self).__init__()
        print("In the C")

c =C()

#以上两种方法的结果都一样
#       In the P
#       In the C

 

二、静态方法、类方法、属性方法

静态方法：

　　通过@staticmethod装饰器即可把其他装饰的方法边变成一个静态方法。静态方法就是，普通的方法，可以在实例化后直接调用，并且在方法里可以通过 self.  调用实例变量或类变量，但静态方法是不可以访问实例变量或类变量的，一个不能访问实例变量和类变量的方法，其实相当于跟类本身已经没什么关系了，它与类唯一的关联就是需要通过类名来调用这个方法：

#！/usr/bin/env python
# -*- coding:utf-8 -*-
# Author：Lyon

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


    @staticmethod
    def eat(self):
        print("%s is eating %s"%(self.name,'food'))

    def talk(self):
        print("%s is talking"%self.name)


d=Dog("Chengronghua")
# d.eat()eat方法已经通过@staticmethod变成了一个静态方法，所以已经不能像之前那样调用了
#静态方法不能访问实例变量或类变量，此时它与类唯的关联就是需要通过类名来调用这个方法

#这里调用有两种方法
#第一种就是调用时传递实例本身给eat方法，如下
d.eat(d)
#第二种就是把eat方法中的self参数给删掉，当然这也就意味着在eat中不能用self，调用实例中的其他变量了
d.talk()

 

 

类方法：

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

#！/usr/bin/env python
# -*- coding:utf-8 -*-
# Author：Lyon
class Dog(object):

    name = "Gouziwei"
    def __init__(self,name):
        self.name=name

    @classmethod  #eat方法将无法访问实例变量，类方法只能访问类变量
    def eat(self):
        print("%s is eating %s"%(self.name,'baozi'))
    def talk(self):
        print("%s is talking"%self.name)

d=Dog("Chengronghua")
d.eat()#没有类变量就会报错
d.talk()

 以上执行结果如果把  name = "Gouziwei" 给注释掉，就会报错：

Traceback (most recent call last):
File "D:/Users/Desktop/python/day7/类方法.py", line 17, in <module>
d.eat()#没有类变量就会报错
File "D:/Users/Desktop/python/day7/类方法.py", line 12, in eat
print("%s is eating %s"%(self.name,'baozi'))
AttributeError: type object 'Dog' has no attribute 'name'

• 类方法无法访问实例变量，只能访问类变量。

 也就是说类方法中，只能用类内部存在的变量，无法与外部的实例变量连接起来。

属性方法：

　　属性方法的作用就是通过@property把一个方法变成一个静态属性:

#！/usr/bin/env python
# -*- coding:utf-8 -*-
# Author：Lyon
class Dog(object):
    def __init__(self,name):
        self.name = name

    @property
    def eat(self):
        print("%s is eating "%self.name)

d = Dog("ChengRongHua")
#出现报错：TypeError: 'NoneType' object is not callable，因为这里已经不是方法了，它变成了一个静态属性，调用直接加.eat就行，不需要加括号
#d.eat()
d.eat

 

• @property.setter可以对其中的属性进行修改。
• @property.deleter可以将属性删除

属性方法有什么作用呢？到这里我发现属性方法好像没什么卵用，把方法变成一个静态属性，那我还不如直接定义静态属性来实现。很多情况下，很多需求是不能简单通过定义静态属性来实现的，现在只要先学着就行了，以后再慢慢体会该作用把。如下是一个航班查询的例子：

#！/usr/bin/env python
# -*- coding:utf-8 -*-
# Author：Lyon
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 has departured already...")
        else:
            print("cannot confirm the flight status....please check later")

f = Flight("CA980")
f.flight_status

实现修改flight_status属性版本：

#！/usr/bin/env python
# -*- coding:utf-8 -*-
# Author：Lyon
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 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("Has changed the flight status to" ,status_dic.get(status))
        
    @flight_status.deleter
    def flight_status(self):
        print("status got removed......")
        
#创建实例        
f = Flight("CA980")
#返回结果
f.flight_status
#触发@flight_status.setter
f.flight_status = 2
#触发@flight_status.delter
del f.flight_status

 

 

三、类的特殊成员方法

1.__doc__   表示类的描述信息

class Foo:
    '''描述类的信息'''
    def func(self):
        pass

print(Foo.__doc__) #输出：描述类的信息

 

2.__module__ 和 __class__

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

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

class C():
    def __init__(self,name):
        self.name= name
        print("in the C....")

 

from aa import C

obj = C("Lyon")
print(obj.__module__)   #输出：aa
print(obj.__class__)    #输出：<class'aa.C'>

 

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

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

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

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

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

#！/usr/bin/env python
# -*- coding:utf-8 -*-
# Author：Lyon

class Foo:

    def __init__(self):
        print("__init__")

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

obj = Foo() #执行__init__
obj()       #执行__call__

 

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

#！/usr/bin/env python
# -*- coding:utf-8 -*-
# Author：Lyon

class Province:
    country = "China"

    def __init__(self,name,count):
        self.name = name
        self.count = count

    def func(self,*args,**kwargs):
        print("func")
#获取类的成员，即：静态字段、访法、
print(Province.__dict__)
#输出：{'func': <function Province.func at 0x000002826C0199D8>, '__dict__': <attribute '__dict__' of 'Province' objects>, '__doc__': None, 'country': 'China', '__init__': <function Province.__init__ at 0x000002826C019950>, '__module__': '__main__', '__weakref__': <attribute '__weakref__' of 'Province' objects>}

obj1 = Province("HeBei",10000)
#获取对象obj的成员
print(obj1.__dict__)
#输出：{'name': 'HeBei', 'count': 10000}

obj2 = Province("HeNan",3888)
#获取obj2的成员
print(obj2.__dict__)
#输出：{'count': 3888, 'name': 'HeNan'}

 

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

class Foo:

    def __str__(self):
        return "Lyon"
    
obj = Foo()
print(obj)
#输出：Lyon

 

8.__getitem__、__setitem__、__delitem__ 用于索引操作，如字典。以上分别表示获取、设置、删除数据。

class Foo:

    def __getitem__(self, item):
        print("__getitem__",item)

    def __setitem__(self, key, value):
        print("__setitem__",key,value)

    def __delitem__(self, key):
        print("__delitem__",key)

obj = Foo()
#自动触发执行 __getitem__
result = obj['k1']
#自动触发执行 __setitem__
obj['k2'] = "Lyon"
#触发__defitem__
del obj['k1']

 9.__new__ 和 __metaclass__ 

　　__new__()方法是在类准备将自身实例化时调用。

　　__new__()方法始终都是类的静态方法，即使没有被加上静态方法装饰器。

class Foo():

    def __new__(self,name):
        self.name = name
        print(self.name)

obj = Foo("Lyon")

 

　　更多关于__new__的详细介绍，向这里戳。

　　在Python中一切皆对象，上述代码中不仅obj是对象，Foo类也是一个对象，而obj是由Foo类的构造方法创建而来，Foo类则是有type类创建而来的，看下：

class Foo():

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

obj = Foo("Lyon")
print(type(obj))    #输出：<class '__main__.Foo'>
print(type(Foo))    #输出：<class 'type'>

 创建类有两种方法：

　　1）普通方式

class Foo(object):

    def func(self):
        print("Hello Lyon")

 

　　2）特殊方法（利用type类创建）

def func(self):
    print("Hello Lyon")

Foo = type("Foo",(object,),{"func":func})
# type第一个参数：类名
# type第二个参数：当前类的基类
# type第三个参数：类的成员

obj = Foo()
obj.func()  #输出：Hello Lyon

 

加上构造方法：

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("Lyon",21)
f.func()

所以类是由type类实例化产生的，那么type类又是由什么产生的呢？

　　类中有一个属性__metaclass__，其用来表示该类由谁来实例化创建，所以可以认为__metaclass__设置一个type类的派生类，从而查看类创建的过程。

 

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

更多关于metaclass（元类）的资料，---->>

四、反射

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

• getattr(object,name,default=None)
• hasattr(object,name)
• setattr(x,y,v)
• delattr(x,y)

方法如下：

#！/usr/bin/env python
# -*- coding:utf-8 -*-
# Author：Lyon

class Foo(object):

    def __init__(self):
        self.name = 'Lyon'

    def func(self):
        return 'func'

obj = Foo()
#检查是否含有成员
hasattr(obj,'name')
hasattr(obj,'func')
print(obj.__dict__)     #输出：{'name': 'Lyon'}     
#获取成员
getattr(obj,'name')
getattr(obj,'func')
print(obj.__dict__)     #输出：{'name': 'Lyon'}   
#设置成员
setattr(obj,'age',18)
setattr(obj,'show',lambda num:num+1)
print(obj.__dict__)     #输出：{'show': <function <lambda> at 0x000001C5AC8097B8>, 'age': 18, 'name': 'Lyon'}   
#删除成员
delattr(obj,'name')
delattr(obj,'show')
delattr(obj,'age')
print(obj.__dict__)     #输出：{}

 

 

动态导入模块

import importlib

#这是解释器自己内部用的
__import__('import_lib.metaclass')  

#与上面这句效果一样，官方建议用这个
importlib.import_module('import_lib.metaclass')

 

 

五、异常处理

1.异常基础

在编程过程中当遇到问题报错时，我们一般不会将错误信息显示给用户，而是显示一个提示的 页面，通俗来说就是不让用户看见大黄页。

try:
    pass
except Exception:
    pass

 

2.异常种类

Python中的异常种类非常多，每个异常专门用于处理某一项异常：

　　AttributeError 试图访问一个对象没有的树形，比如foo.x，但是foo没有属性x
　　IOError 输入/输出异常；基本上是无法打开文件
　　ImportError 无法引入模块或包；基本上是路径问题或名称错误
　　IndentationError 语法错误（的子类） ；代码没有正确对齐
　　IndexError 下标索引超出序列边界，比如当x只有三个元素，却试图访问x[5]
　　KeyError 试图访问字典里不存在的键
　　KeyboardInterrupt Ctrl+C被按下
　　NameError 使用一个还未被赋予对象的变量
　　SyntaxError Python代码非法，代码不能编译(个人认为这是语法错误，写错了）
　　TypeError 传入对象类型与要求的不符合
　　UnboundLocalError 试图访问一个还未被设置的局部变量，基本上是由于另有一个同名的全局变量，导致你以为正在访问它
　　ValueError 传入一个调用者不期望的值，即使值的类型是正确的

ArithmeticError
AssertionError
AttributeError
BaseException
BufferError
BytesWarning
DeprecationWarning
EnvironmentError
EOFError
Exception
FloatingPointError
FutureWarning
GeneratorExit
ImportError
ImportWarning
IndentationError
IndexError
IOError
KeyboardInterrupt
KeyError
LookupError
MemoryError
NameError
NotImplementedError
OSError
OverflowError
PendingDeprecationWarning
ReferenceError
RuntimeError
RuntimeWarning
StandardError
StopIteration
SyntaxError
SyntaxWarning
SystemError
SystemExit
TabError
TypeError
UnboundLocalError
UnicodeDecodeError
UnicodeEncodeError
UnicodeError
UnicodeTranslateError
UnicodeWarning
UserWarning
ValueError
Warning
ZeroDivisionError

 实例：

dic = ["wupeiqi", 'alex']
try:
    dic[10]
except IndexError, e:
    print e

dic = {'k1':'v1'}
try:
    dic['k20']
except KeyError, e:
    print e

s1 = 'hello'
try:
    int(s1)
except ValueError, e:
    print e

上述的异常类只能用来处理指定的异常情况，还有非指定异常处理：

# 未捕获到异常，程序直接报错
 
s1 = 'hello'
try:
    int(s1)
except IndexError,e:
    print e

我们还可以这样写

s1 = 'hello'
try:
    int(s1)
except IndexError,e:
    print e
except KeyError,e:
    print e
except ValueError,e:
    print e

万能异常，在python的异常中，有一个万能异常：Exception，它可以捕获任意异常，即：

s1 = 'hello'
try:
    int(s1)
except Exception,e:
    print e

在我们实际应用中，对于特殊处理或提醒的异常需要先定义，最后定义Exception来确保程序正常运行。如下：

s1 = 'hello'
try:
    int(s1)
except KeyError,e:
    print '键错误'
except IndexError,e:
    print '索引错误'
except Exception, e:
    print '错误'

3.异常其他结构

try:
    # 主代码块
    pass
except KeyError,e:
    # 异常时，执行该块
    pass
else:
    # 主代码块执行完，执行该块
    pass
finally:
    # 无论异常与否，最终执行该块
    pass

4.主动触发异常

try:
    raise Exception('错误了。。。')
except Exception,e:
    print e

5.自定义异常

class WupeiqiException(Exception):
 
    def __init__(self, msg):
        self.message = msg
 
    def __str__(self):
        return self.message
 
try:
    raise WupeiqiException('我的异常')
except WupeiqiException,e:
    print e

6.断言

# assert 条件
 
assert 1 == 1
 
assert 1 == 2

断定1等于1，为True则继续往下运行，为False则执行中断

注：本文仅为学习笔记、摘要。

详细来源：http://www.cnblogs.com/alex3714/articles/5213184.html

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