python基础八

面向对象的好处

更容易扩展、提高代码使用效率，使你的代码组织性更强，

更清晰，更适合复杂项目的开发

封装

把功能的实现细节封装起来，只暴露调用接口

继承

多态

接口的继承

定义

类   ===> 模版

对象===> 实例化的类

属性

私有属性    __private

公有属性    存在类的内存里，所有实例共享

成员属性    ===>实例变量

方法  ==>函数

构造函数

析构函数：实例被销毁（手动删除实例的变量，或者程序结束）的时候，自动执行，

新式类

object

super(Myclass,self).__init__(...)

多继承  继承路径

广度优先

经典类

class Dog:

parent_class.__init__(self....)

深度优先

抽象接口

在子类定义一个需要写的接口，如果子类接口不写，就报父类定义的报错。

class Alert(object):
    def send(self):
        '''报警消息发送接口'''
        raise NotImplementedError

class MailAlert(Alert):
    # pass
    def send(self,msg):
        print("----sending...",msg)

m = MailAlert()
m.send('fd')

静态方法&类方法&属性方法

class Person(object):
    name='rain'
    def __init__(self,name):
        self.name=name

    @staticmethod
    def eat(name,food):#静态方法既不能访问公有属性，也不能访问实例属性
        print("%s is eating %s"%(name,food))

    @classmethod
    def walk(self): #类方法，只能访问类的公有属性，不能访问实例属性
        print("%s is walking"%self.name)

    @property  #属性方法，作用是把一个方法变成一个静态属性
    def talk(self):
        print("%s says"%self.name)

    @talk.setter　　#修改属性
    def talk(self,msg):
        print("set msg:",msg)

    @talk.deleter　　#删除属性
    def talk(self):
        print("delete talk...")

p=Person("Jack")
Person.eat("Jack","apple")
Person.walk()
p.talk
p.talk="hello"
del p.talk

以上代码运行结果

Jack is eating apple
rain is walking
Jack says
set msg: hello
delete talk...

类的特殊成员方法

1. __doc__　　表示类的描述信息

2. __module__ 和  __class__ 

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

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

class Flight(object):
    '''Flight status checking'''
    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):
        print("flight status is %s"%status)

f = Flight("CA980")
print(f.__doc__)
print(f.__module__)
print(f.__class__)

以上代码运行结果

Flight status checking
__main__
<class '__main__.Flight'>

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

4.__del__

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

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

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

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

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

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

class Foo:

    def __str__(self):
        return 'alex li'

obj = Foo()
print (obj)
# 输出：alex li

8.__getitem__、__setitem__、__delitem__

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

class Flight(object):
    def __init__(self,name):
        self.flight_name = name
        self.__status=None

    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):
        self.__status=status
        print("changed status to %s"%self.__status)

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

    def __str__(self):
        return "<flight:%s,status:%s>"%(self.flight_name,self.__status)

    def __getitem__(self, item):
        print("get item",item)
        return 22
    def __setitem__(self, key, value):
        print("set key",key,value)
    def __delitem__(self, key):
        print("deleteing",key)

f = Flight("CA980")
f()         #__call__
print(f)    #__str__
print(f["age"])         #__getitem__
f["age"]=26         #__setitem__
del f["age"]        #__delitem__

以上代码输出结果

__call: () {}
<flight:CA980,status:None>
get item age
22
set key age 26
deleteing age

9、__module__

以字符串的形式导入模块

F:\zhou\python\day8\flight_status.py内容如下

class Flight(object):
    '''Flight status checking'''
    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):
        print("flight status is %s"%status)

f = Flight("CA980")

实例

mod=__import__('day8.flight_status',fromlist=True)
print(mod)
f=mod.Flight('CA980')
# print(f)
f.flight_status

以上代码运行结果

<module 'day8.flight_status' from 'F:\\zhou\\python\\day8\\flight_status.py'>
checking flight CA980 status
flight is arrived...

10. __new__ \ __metaclass__

class Foo(object):

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

f = Foo("alex")

print(type(f))
print(type(Foo))

以上代码运行结果

<class '__main__.Foo'>
<class 'type'>

上述代码中，obj 是通过 Foo 类实例化的对象，其实，不仅 obj 是一个对象，Foo类本身也是一个对象，因为在Python中一切事物都是对象。

f对象是Foo类的一个实例，Foo类对象是 type 类的一个实例，即：Foo类对象 是通过type类的构造方法创建。

创建类有两种方式：

1）普通类

class Foo(object):

    def func(self):
        print 'hello alex'

2）特殊方式

def func(self):
    print 'hello wupeiqi'

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

实例

def talk(self,msg):
    print("%s is talking:%s"%(self,msg))
Dog=type("Dog",(object,),{"talk":talk})
print(type(Dog))
d = Dog()
d.talk("efdsd")

def talk(self,msg):
    print("%s is talking:%s"%(self.name,msg))
def __init__(self,name):
    self.name=name
Dog=type("Dog",(object,),{"talk":talk,"__init__":__init__})
print(type(Dog))
d = Dog("Haitao")
d.talk("efdsd")
Dog.talk

以上代码运行结果

<class 'type'>
<__main__.Dog object at 0x000002A339552668> is talking:efdsd
<class 'type'>
Haitao is talking:efdsd

__metaclass__

__metaclass__可以设置一个类的派生类，来查看类创建的过程。

class MyType(type):
    def __init__(self, child_cls, bases=None, dict=None):
        print("--MyType init---", child_cls,bases,dict)
        #super(MyType, self).__init__(child_cls, bases, dict)

    # def __new__(cls, *args, **kwargs):
    #     print("in mytype new:",cls,args,kwargs)
    #     type.__new__(cls)
    def __call__(self, *args, **kwargs):
        print("in mytype call:", self,args,kwargs)
        obj = self.__new__(self,args,kwargs)

        self.__init__(obj,*args,**kwargs)

class Foo(object,metaclass=MyType): #in python3
    # __metaclass__ = MyType #in python2

    def __init__(self, name):
        self.name = name
        print("Foo ---init__")

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

    def __call__(self, *args, **kwargs):
        print("Foo --call--",args,kwargs)
# 第一阶段：解释器从上到下执行代码创建Foo类
# 第二阶段：通过Foo类创建obj对象
obj = Foo("Alex")
# print(obj.name)

异常处理

1、基本结构

2、复杂结构

3、异常对象

　　try:

　　　　代码块

　　　　代码块

　　　　代码块

　　　　代码块

　　except Exception as obj:

　　　　obj对象中封装了当前触发的错误信息

　　　　...（将错误信息写入数据库）

　　class Message:

　　　　def __init__(self,name):

　　　　　　self.name=name

　　obj=Message('ssss')

4、异常种类

Exception能将所有的异常都捕获

其它        只能处理某一种情况

try:

　　代码块

　　代码块

　　代码块

except ValueError as obj:

　　pass

except KeyError as obj:

　　pass

5、主动触发异常

　　raise Exception('邮件发送失败')

　　def execute():
　　try:

　　　　result = foo1()
　　　　if result:
　　　　　　pass
　　　　else:
　　　　　　raise Exception('邮件发送失败')
　　　　foo2()
　　exception Exception as e:

　　　　#记录日志

6、断言

如果条件不成立，直接抛异常

print(1)
assert 1!=1

print(2)

以上代码运行结果

Traceback (most recent call last):
1
  File "F:/zhou/python/day8/断言.py", line 6, in <module>
    assert 1!=1
AssertionError

7、自定义异常处理

class HaiTaoError(Exception):
    def __init__(self, message):
        self.msg = message
        super(HaiTaoError, self).__init__(message)

try:
    name="alex"
    if name != "haitao":
        raise HaiTaoError('fffff')
except IndexError as e:
    print(e,e.msg)
except Exception as e:
    print(e,1111)

以上代码运行结果

fffff 1111

8、反射

1）允许用户输入

　　　　account/login

　　　　account/logout

　　　　home/index

　　　　home/order

2）看到不同的结果

3）404

li=[account/login,account/logout,home/index,home/order]

inp=input('>>')

 

hashattr（容器，'名称'）    #以字符串的形式判断某个对象中是否含有指定的属性

getattr（容器，'名称'）       #以字符串的形式获取某个对象中指定的属性

setattr（容器，'名称'）       #以字符串的形式设置某个对象中指定的属性

delattr（容器，'名称'）       #以字符串的形式删除某个对象中指定的属性

方法一：

from controller import account

action=input('>>')
if (hasattr(account,action)):
    v= getattr(account,action)
    result=v()
else:
    result='
print(result)

方法二：

inp=input('请输入url>>:')

m,n= inp.split('/')

from controller import account

func=getattr(account,n)
result=func()
print(result)

方法三（导入多个py文件）：

inp=input('请输入url>>:')
m,n= inp.split('/')
mod= __import__('controller.%s'%m,fromlist=True)
func=getattr(mod,n)
result=func()
print(result)

最终完整版：

while True:
    try:
        inp=input('请输入url>>:')
        m,n= inp.split('/')
        mod= __import__('controller.%s'%m,fromlist=True)
        if hasattr(mod,n):
            func=getattr(mod,n)
            result=func()
        else:
            result=404
    except Exception as e:
        result=500
    print(result)

反射本质上是到某个对象中找东西