Python - 面对对象(其他相关,异常处理,反射,单例模式,等..)

目录

  • Python - 面对对象(其他相关,异常处理,反射,等..)

    • 一、isinstance(obj, cls)
    • 二、issubclass(sub, super)
    • 三、异常处理
      • 1. 异常处理
      • 2.异常种类
      • 3.异常其他结构
      • 4.主动触发异常
      • 5.自定义异常
      • 6.断言
    • 四、反射
    • 五. 单例模式

Python - 面对对象(其他相关,异常处理,反射,等..)

一、isinstance(obj, cls)

检查是否obj是否是类 cls 的对象

class Foo(object):
    pass

obj = Foo()

isinstance(obj, Foo)

二、issubclass(sub, super)

检查sub类是否是 super 类的派生类

class Foo(object):
    pass

class Bar(Foo):
    pass

issubclass(Bar, Foo)

三、异常处理

1. 异常处理

在编程过程中为了增加友好性，在程序出现bug时一般不会将错误信息显示给用户，而是现实一个提示的页面，通俗来说就是不让用户看见大黄页！！！

try:
    pass
except Exception,ex:
    pass

需求：将用户输入的两个数字相加

while True:
    num1 = raw_input('num1:')
    num2 = raw_input('num2:')
    try:
        num1 = int(num1)
        num2 = int(num2)
        result = num1 + num2
    except Exception, e:
        print '出现异常，信息如下：'
        print e

2.异常种类

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

常用的异常

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

实例

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

所以，写程序时需要考虑到try代码块中可能出现的任意异常，可以这样写：

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

四、反射

python中的反射功能是由以下四个内置函数提供：hasattr、getattr、setattr、delattr，改四个函数分别用于对对象内部执行：检查是否含有某成员、获取成员、设置成员、删除成员。

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')

类是对象

class Foo(object):

    staticField = "old boy"

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

    def func(self):
        return 'func'

    @staticmethod
    def bar():
        return 'bar'

print getattr(Foo, 'staticField')
print getattr(Foo, 'func')
print getattr(Foo, 'bar')

反射也是对象

#!/usr/bin/env python
# -*- coding:utf-8 -*-

"""
程序目录：
    home.py
    index.py

当前文件：
    index.py
"""

import home as obj

#obj.dev()

func = getattr(obj, 'dev')
func()

五. 单例模式

设计模式之单例模式

单例设计模式是怎么来的？
在面向对象的程序设计中，当业务并发量非常大时，那么就会出现重复创建相同的对象，每创建一个对象就会开辟一块内存空间，而这些对象其实是一模一样的，那么有没有办法使用得内存对象只创建一次，然后再随处使用呢？单例模式就是为了解决这个问题而产生的。

实现方式：
１、创建一个类静态字段（类变量）__instance
２、创建一个静态函数，通过函数的逻辑判断 __instance 是否已存在，如不存在就将对象值赋于__instance，即__instance = 类(),否则直接返回__instance，也即创建的对象都是一样的
３、使用单例模式创建对象时直接通过类调用静态函数创建即可

#普通模式
class A(object):
    def __init__(self,name,male):
        self.name = name
        self.name = male

#实例化多个对象
obj1 = A('ben','boy')
obj2 = A('min','girl')
obj3 = A('miao','boy')
##打印内存地址，可以看到内存地址都是不一样的
print id(obj1),id(obj2),id(obj3)

#单例模式
class A(object):
    __instance = None
    def __init__(self,name,male):
        self.name = name
        self.name = male
    @staticmethod
    def create_obj():
        if not A.__instance:
            A.__instance = A('ben','boy')
            return A.__instance
        else:
            return A.__instance

#单例模式实例化多个对象
obj1 = A.create_obj()
obj2 = A.create_obj()
obj3 = A.create_obj()
##打印内存地址，可以看到内存地址都是一样的
print id(obj1),id(obj2),id(obj3)

result :

1 >>> #普通模式
 2 ... class A(object):
 3 ...     def __init__(self,name,male):
 4 ...         self.name = name
 5 ...         self.name = male
 6 ...
 7 >>> #实例化多个对象
 8 ... obj1 = A('ben','boy')
 9 >>> obj2 = A('min','girl')
10 >>> obj3 = A('miao','boy')
11 >>> ##打印内存地址，可以看到内存地址都是不一样的
12 ... print id(obj1),id(obj2),id(obj3)
13 140230687882448 140230687882512 140230687882576
14 >>>
15 >>> #单例模式
16 ... class A(object):
17 ...     __instance = None
18 ...     def __init__(self,name,male):
19 ...         self.name = name
20 ...         self.name = male
21 ...     @staticmethod
22 ...     def create_obj():
23 ...         if not A.__instance:
24 ...             A.__instance = A('ben','boy')
25 ...             return A.__instance
26 ...         else:
27 ...             return A.__instance
28 ...
29 >>> #单例模式实例化多个对象
30 ... obj1 = A.create_obj()
31 >>> obj2 = A.create_obj()
32 >>> obj3 = A.create_obj()
33 >>> ##打印内存地址，可以看到内存地址都是一样的
34 ... print id(obj1),id(obj2),id(obj3)
35 140230687882832 140230687882832 140230687882832
36 >>>

原文地址：https://www.cnblogs.com/konghui/p/10479593.html

时间： 2024-10-07 07:36:46

Python - 面对对象(其他相关,异常处理,反射,单例模式,等..)的相关文章

Python学习：16.Python面对对象（三、反射，构造方法，静态字段，静态方法）

一.构造方法 在使用类创建对象的时候(就是类后面加括号)就自动执行__init__方法. class A: def __init__(self): print('A') class B: def __init__(self): print('B') obj = A() #虽然只是创建了obj对象,但是执行了__init__方法,输出了A Python中派生类可以继承父类的构造方法 1.基于super() 遇到super()就表示去执行父类的xxx属性 class A: def __init__(

Python - 面对对象(基础)

目录 Python - 面对对象(基础) 一. 概述 二. 创建类和对象 三. 面向对象三大特征 封装 继承 多态 Python - 面对对象(基础) 一. 概述 面向过程:根据业务逻辑从上到下写垒代码 函数式:将某功能代码封装到函数中,日后便无需重复编写,仅调用函数即可 面向对象:对函数进行分类和封装,让开发"更快更好更强..." 面向过程编程(Object Oriented Programming,OOP,面向对象程序设计) 最易被初学者接受,其往往用一长段代码来实现指定功能,开发

15、python面对对象之类和对象

前言:本文主要介绍python面对对象中的类和对象,包括类和对象的概念.类的定义.类属性.实例属性及实例方法等. 一.类和对象的概念 问题:什么是类?什么是实例对象? 类:是一类事物的抽象概念,不是真实存在的,描绘了该类事物共有的特征和行为 例如:猫类.狗类.鸟类.车类等 实例对象:某类事物的具体个体,是该类事物的具体表现,它是真实存在的 例如:“张三”是具体的某个“人“,”二哈“是具体的某个”狗“ 二.类的定义 关键字:class 定义类的方法: 方式一:class 类名: 方式二:class

16、python面对对象之类和继承

前言:本文主要介绍python面对对象中的类和继承,包括类方法.静态方法.只读属性.继承等. 一.类方法 1.类方法定义 使用装饰器@classmethod装饰,且第一个参数必须是当前类对象,该参数名一般约定为“cls",通过它来传递类的属性和方法 (不能传递实例属性和实例方法),跟实例方法的self用法相似. 2.类方法的调用 实例对象和类对象都可以调用 3.应用场景 在需要站在类的角度执行某个行为时,那么就可以定义为类方法 class Student: def __init__(self,

python面对对象笔记整理

首先声明本文纯属笔记 1 面对对象三大特性: 1.1 封装:将字段封装在类中,通过类中self调用或者通过对象来调用. 1.2 继承:一般的继承不再叙述,多继承参考另一篇文章 python多继承 1.3 多态:因为python的函数可以传入多种类型的参数,所以不存在多态.python这种形式属于鸭子类型,也就是长得像鸭子的类型都可以. 2

python面对对象

中间隔有python模块没有进行更新,是因为觉得模块的操作应用更应该记牢,再次先不更新 1,面对对象的作用: 能简化思路和代码 2,面对对象的思路: 不着急直接去计算/操作代码获取结果 从一个大的问题中,要到要描述的角色 将角色的属性和行为抽象出来 形成一个模子 后期用到角色的时候,都围绕这个模子来操作.3,类 :一类抽象的事物,是描述了一类事物有哪些属性或者行为,但是不具体.4,实例:就是一个依托于类的规范存在的,被赋予了具体属性值得实际存在的物体5,对象 :就是实例--给类中约束的属性赋了具

python面向对象其他相关-异常处理-反射

1.isinstance(obj, cls) 检查是否obj是否是类 cls 的对象   2.issubclass(sub, super) 检查sub类是否是 super 类的派生类 n1 = 10 a1 = "123" print type(n1) print type(a1) print isinstance(n1,int) #判断n1是否属于int类型,正确返回True print '-->',isinstance(n1,str) #判断n1是否属于str类型,正确返回Tr

Python 面对对象编程

面向对象编程: 面向过程:根据业务逻辑从上到下写垒代码 函数式:将某功能代码封装到函数中,日后便无需重复编写,仅调用函数即可 面向对象:对函数进行分类和封装,让开发"更快更好更强..." 面向过程编程最易被初学者接受,其往往用一长段代码来实现指定功能,开发过程中最常见的操作就是粘贴复制,即:将之前实现的代码块复制到现需功能处. 封装 封装最好理解了.封装是面向对象的特征之一,是对象和类概念的主要特性. 封装,也就是把客观事物封装成抽象的类,并且类可以把自己的数据和方法只让可信的类或者对

python面对对象编程

基本概念 class类 一个类即是对一类拥有相同属性的对象的抽象.蓝图.原型.在类中定义了这些对象的都具备的属性(variables(data)).共同的方法 Object 对象 一个对象即是一个类的实例化后实例,一个类必须经过实例化后方可在程序中调用,一个类可以实例化多个对象,每个对象亦可以有不同的属性,就像人类是指所有人,每个人是指具体的对象,人与人之前有共性,亦有不同 Encapsulation 封装在类中对数据的赋值.内部调用对外部用户是透明的,这使类变成了一个胶囊或容器,里面包含着类的