高手的存在,就是让服务10亿人的时候,你感觉只是为你一个人服务......

Welcome to Python

目录
  1. 1. python的初印象
  2. 2. 开发环境
  3. 3. python基础数据类型
  4. 4. 输入输出
    1. 4.1. 输入输出demo
  5. 5. if - elif - else语句
    1. 5.1. if-elif-else语法
      1. 5.1.1. if-elif-else demo:
    2. 5.2. 逻辑运算符
  6. 6. 循环while
    1. 6.1. 语法:
    2. 6.2. while demo:
  7. 7. for 循环
    1. 7.1. for循环语法
    2. 7.2. break 和 continue
  8. 8. 字符串、列表、元组、字典
    1. 8.1. 字符串
      1. 8.1.1. 下标
      2. 8.1.2. 切片
      3. 8.1.3. find
        1. 8.1.3.1. find demo 判断文件以.py结尾
      4. 8.1.4. count
      5. 8.1.5. replace
      6. 8.1.6. split
      7. 8.1.7. capitalize
      8. 8.1.8. title
      9. 8.1.9. upper &&lower
      10. 8.1.10. startswith && endswith
    2. 8.2. 列表
      1. 8.2.1. 列表循环
      2. 8.2.2. 列表增、删、改、查
        1. 8.2.2.1. 列表增
          1. 8.2.2.1.1. append
          2. 8.2.2.1.2. insert
          3. 8.2.2.1.3. extend
        2. 8.2.2.2. 列表改
        3. 8.2.2.3. 列表查
        4. 8.2.2.4. 列表删
    3. 8.3. 元组
    4. 8.4. 字典
      1. 8.4.0.0.1. 字典添加元素
      2. 8.4.0.0.2. 字典修改元素
      3. 8.4.0.0.3. 字段删除元素
      4. 8.4.0.0.4. 字典keys & values
      5. 8.4.0.0.5. items
      6. 8.4.0.0.6. has_key
      7. 8.4.0.0.7. 字典遍历
  • 9. 函数
    1. 9.1. 函数的参数
      1. 9.1.1. 缺省参数
      2. 9.1.2. 不定长参数
    2. 9.2. 函数返回值
    3. 9.3. 局部变量 && 全局变量
  • 10. 面向对象编程
    1. 10.1. 类与对象
      1. 10.1.1. _ init _ 方法
        1. 10.1.1.1. _ init() _ 方法参数
    2. 10.2. 理解self
    3. 10.3. _ str _方法
    4. 10.4. 私有属性
    5. 10.5. 私有方法
    6. 10.6. _ del _()方法
    7. 10.7. 继承
      1. 10.7.1. 重写
      2. 10.7.2. 多继承
    8. 10.8. 多态
    9. 10.9. 类方法
  • 11. 异常
    1. 11.1. 抛出异常
      1. 11.1.1. demo: 自定义一个异常,手动抛出。
  • Life is short. You need Python.

    Alt text


    python的初印象

    在学习python之前,我印象的python有几个特点:

    1. 写更少的代码。 比如实现一个功能,C需要100行,java需要20~30 行,Python只需要几行。

    2. 解释型的语言。程序不需要编译,每个语句都是执行的时候才翻译。

    3. 面向对象。 降低了开发难度,适用团队开发。

    4. 强大的第三方库。比如最近火热的机器学习。


    开发环境

    windows平台使用的sublime text3+ python。
    https://www.sublimetext.com/
    https://www.python.org/downloads/

    linux下推荐使用的ipython。
    https://github.com/ipython/ipython
    解压后:python setup.py install,安装即可。


    python基础数据类型

    Alt text


    输入输出

    print()输出
    input() &&raw_input():输入

    python2中input输入的为整型,raw_input输入的为字符串。

    Alt text


    输入输出demo

    1
    2
    3
    4
    5
    6
    7
    #!/bin/python
    #coding=utf-8
    name = raw_input("请输入姓名:")
    passwd = raw_input("请输入密码:")
    qq = raw_input("请输入QQ号:")

    print ("姓名:%s 密码:%s QQ号为:%s" %(name,passwd,qq))

    Alt text


    if - elif - else语句

    if-elif-else语法

    if 要判断的条件:
    …..
    elif 要判断的条件 :
    ……
    else
    ……

    if-elif-else demo:

    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    a = -8

    if a > 0:

    print (a)

    elif a = 0:

    print (a+8)

    else :
    print (a+10)

    逻辑运算符

    and : 与
    or :或
    not :非


    循环while

    语法:

    while 条件:
    ……

    while demo:

    打印一个三角图形:

    1
    2
    3
    4
    a = 1
    while a < 6:
    print('*'*a)
    a+=1;

    Alt text

    打印99乘法表:

    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    from __future__ import print_function
    a = 1
    while a <= 9 :
    i = 1
    while i<=a :
    sum = i*a
    print("%d*%d=%d"%(i,a,sum),end = ' ')
    i+=1
    print("\n")

    a+=1

    Alt text


    for 循环

    for循环语法

    for 变量 in xxx :
    ……

    1
    2
    3
    name = "abcdefg"
    for x in name:
    print x

    break 和 continue

    1
    2
    3
    4
    5
    6
    7
    8
    name = "abcdefg"

    for x in name:

    if x=="b":
    continue
    if x=="d":
    break

    输出:

    a
    c


    字符串、列表、元组、字典

    字符串:xxxx
    列表:[xxxx]
    元组:(xxxx)
    字典{xxxx:xxxx}

    字符串

    双引号或者单引号中的数据,就是字符串。
    a=”abc defg”
    或者
    a=’abc defg’

    下标

    name= “abcdef”

    name[0]为a
    name[1]为b
    name[5]为f
    name[-1]为f,取最后一个

    切片

    切片是对字符串截取的操作,[起始:结束:步长]。
    选取的区间为左闭右开。
    name=”abcdef”

    name[0:3]为abc
    name[0:3:2] 为ac,每次取2步
    name[3:]为def,取d后面的字符串
    name[-1:-3:-1] 为fe,从后往前取值,步长为-1(向前取)
    name[-1::-1]为fedcba
    name[::-1]为fedcba

    find

    检测字符串中是否包含字符串,包含返回索引值,否则返回-1

    1
    2
    3
    4
    5
    6
    str1 = "abcdefg"
    str2 = "abc"
    str3 = "ef"
    print (str1.find(str2))
    print (str1.find(str3))
    print (str1.rfind(str3)) #从后往前找

    输出:

    0
    4
    4

    find demo 判断文件以.py结尾

    这里不使用endswith函数,使用find和下标实现

    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    fileName=raw_input("please input fileName:")

    if fileName.find(".") == -1 :
    print ("please input right fileName")

    else :
    str = fileName.rfind(".")
    fileEnd = fileName[-1:str:-1]
    if fileEnd != "yp" :
    print "please input python file"
    else:
    print fileName

    count

    返回字符串出现的次数

    1
    2
    3
    name = "abc abc abcd"
    print name.count("abc")
    print name.count("abc",3,8)#从3~8位置找

    输出:

    3
    1

    replace

    从字符串中替换

    1
    2
    3
    name = "abc abc abcd"
    print name.replace("abc","ABC")
    print name.replace("abc","ABC",1)#替换1

    输出:

    ABC ABC ABCd
    ABC abc abcd

    split

    分割字符串

    1
    2
    name = 'abc .abc. abcd'
    print name.split(".")

    输出:

    [‘abc ‘, ‘abc’, ‘ abcd’]

    capitalize

    把字符串第一个字符大写

    1
    2
    name = 'abc abc'
    print name.capitalize()

    输出:

    Abc abc

    title

    把字符串中的每个单词首字母大写

    1
    2
    name = 'abc abc'
    print name.title()

    输出:

    Abc Abc

    upper &&lower

    upper 把字符串大写
    lower 把字符串小写

    1
    2
    3
    name = 'Abc aBC'
    print name.upper()
    print name.lower()

    输出:

    ABC ABC
    abc abc

    startswith && endswith

    startswith:检查字符串以XX开头,区分大小写
    endswith:检查字符串以XX结尾,区分大小写

    1
    2
    3
    name = 'Abc aBC'
    print name.startswith("Abc")
    print name.endswith('aBC')

    输出:

    True
    True


    列表

    有点像c、java中的数组

    [100,2000,200000,”abcs”] 可以同时放整型、字符串等多种数据类型。

    列表循环

    1
    2
    3
    4
    name = [1,'a','aaa']

    for x in name:
    print x

    输出:

    1
    a
    aaa

    使用枚举enumerate(),可以打印出下标

    1
    2
    3
    names = ['a','b','c','d']
    for name in enumerate(names) :
    print name

    输出:

    (0, ‘a’)
    (1, ‘b’)
    (2, ‘c’)
    (3, ‘d’)

    列表增、删、改、查

    列表增

    append

    通过append添加元素

    1
    2
    3
    name = [1,'a','aaa']
    name.append("bbb")
    print name

    输出:

    [1, ‘a’, ‘aaa’, ‘bbb’]

    insert

    通过insert插入元素,insert(index,object)

    1
    2
    3
    name = [1,'a','aaa']
    name.insert(1,'ss')
    print name

    输出:

    [1, ‘ss’, ‘a’, ‘aaa’]

    extend

    通过extend将另外一个集合中的元素添加到列表中。

    1
    2
    3
    4
    name1 = [1,2,3]
    name2 = ['a','b','c']
    name1.extend(name2)
    print name1

    输出:

    [1, 2, 3, ‘a’, ‘b’, ‘c’]

    列表改

    修改元素的时候,需要通过下标来确定要修改的元素,然后再修改。

    1
    2
    3
    name = [1,2,3]
    name[0] = 99#修改
    print name

    输出:

    [99, 2, 3]

    列表查

    in:存在
    not in: 不存在

    1
    2
    3
    4
    name = [1,2,3]
    print (1 in name)
    print (4 in name )
    print (4 not in name)

    输出:

    True
    False
    True

    列表删

    del:根据下标删除元素
    pop:删除最后一个元素
    remove:根据元素的值删除

    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    name1 = [1,2,3,4,5,6,7,8,9,0]
    name2 = [1,2,3,4,5,6,7,8,9,0]
    name3 = [1,2,3,4,5,6,7,8,9,0]
    name4 = [1,2,3,4,5,6,7,8,9,0]
    del name1 [0]
    del name2 [0:4]
    name3.pop()
    name4.remove(1)
    print name1
    print name2
    print name3
    print name4

    输出:

    [2, 3, 4, 5, 6, 7, 8, 9, 0]
    [5, 6, 7, 8, 9, 0]
    [1, 2, 3, 4, 5, 6, 7, 8, 9]
    [2, 3, 4, 5, 6, 7, 8, 9, 0]


    元组

    与列表类似,不同之处在于元祖的元素不能修改。
    name = (1,2,3,4,5)

    常用于存储常量值。


    字典

    类似java中的map

    1
    2
    3
    4
    5
    name = {"name1":"lisi","name2":"wangwu"}
    print name
    print name['name1']
    print name.get('name1')
    print name.get('name5',"none") #没有取到name5,取none

    输出:

    {‘name2’: ‘wangwu’, ‘name1’: ‘lisi’}
    lisi
    lisi
    none

    字典添加元素
    1
    2
    3
    name = {"name1":"lisi","name2":"wangwu"}
    name['name3'] = "maliu"
    print name

    输出:

    {‘name2’: ‘wangwu’, ‘name3’: ‘maliu’, ‘name1’: ‘lisi’}

    字典修改元素
    1
    2
    3
    name = {"name1":"lisi","name2":"wangwu"}
    name['name1'] = "maliu"
    print name

    输出:

    {‘name2’: ‘wangwu’, ‘name1’: ‘maliu’}

    字段删除元素

    del:按key删
    clear:删除全部元素

    1
    2
    3
    4
    5
    6
    name = {"name1":"lisi","name2":"wangwu","name3":"maliu"}
    del name['name1']
    print name

    name.clear()
    print name

    输出:

    {‘name2’: ‘wangwu’, ‘name3’: ‘maliu’}
    {}

    字典keys & values
    1
    2
    3
    name = {"name1":"lisi","name2":"wangwu","name3":"maliu"}
    print name.keys()
    print name.values()

    输出:

    [‘name2’, ‘name3’, ‘name1’]
    [‘wangwu’, ‘maliu’, ‘lisi’]

    items
    1
    2
    name = {"name1":"lisi","name2":"wangwu","name3":"maliu"}
    print name.items()

    输出:

    [(‘name2’, ‘wangwu’), (‘name3’, ‘maliu’), (‘name1’, ‘lisi’)]

    has_key

    has_key(key)如果key在字典中,返回true

    1
    2
    name = {"name1":"lisi","name2":"wangwu","name3":"maliu"}
    print name.has_key('name1')

    输出:

    True

    字典遍历

    把字典转化成列表

    1
    2
    3
    names = {"name1":"lisi","name2":"wangwu","name3":"maliu"}
    for name,value in names.items():
    print name,value

    输出:

    name2 wangwu
    name3 maliu
    name1 lisi


    函数

    一直觉得python之所以这么牛B,主要因为强大的第三方函数库。

    python的函数定义和调用很简单。

    def methodName(参数) :
    ……

    1
    2
    3
    4
    def printName(name):
    print ("hello %s" %name)

    printName("lisi")

    输出:

    hello lisi


    函数的参数

    python支持不按照顺序传参

    1
    2
    3
    4
    5
    6
     def numAdd(a,b):
    sum = a + b
    print ("%s+%s=%s" %(a,b,sum))

    numAdd(100,200)
    numAdd(b=100,a=200)##指定参数值

    输出:

    100+200=300
    200+100=300

    缺省参数

    函数中指定一个参数的值,调用的时候可以不用传值。

    1
    2
    3
    4
    5
    def test(a,b=110):
    print a,b

    test(1,2)
    test(1)#调用的时候b不传值

    输出:

    1 2
    1 110

    不定长参数

    参数的数量不确定。
    参数名为元组数据类型
    *
    参数名为字典数据类型

    1
    2
    3
    4
    5
    6
    def test(a,*b,**c):
    print a,b,c
    print (type(b))
    print (type(c))

    test(1,2,3,4,num1=10,num2=100)

    输出:

    1 (2, 3, 4) {‘num1’: 10, ‘num2’: 100}


    函数返回值

    return xxx
    return xxx,xxx 可以返回多个值

    1
    2
    3
    4
    5
    6
    def numAdd(a,b):
    sum = a + b
    return sum

    sum = numAdd(100,200)
    print sum

    输出:

    300

    1
    2
    3
    4
    5
    6
    7
    8
    #return多个值
    def getNameAndAge():
    name = 'lisi'
    age = 18
    return name,age

    name,age = getNameAndAge()
    print name,age

    输出:

    lisi 18


    局部变量 && 全局变量

    简单来说,函数内部的为局部变量,函数外的为全局变量。

    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    '''
    全局变量
    '''

    num1 = 10
    num2 = 20

    def A():
    num1 = 100#局部变量
    print num1,num2

    A()
    print num1,num2

    输出:

    100 20
    10 20


    面向对象编程

    一切皆对象!


    类与对象

    类的构成

    类名
    属性
    方法

    对象

    对象名= 类名()

    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    #定义类名
    class Person :

    #定义方法
    def eat(self):
    print ('eat food: %s' %self.food)

    #创建对象
    wangwu = Person()
    #添加对象属性
    wangwu.food = 'noodle'
    #对象的方法调用
    wangwu.eat()

    输出:

    eat food: noodle


    _ init _ 方法

    类似java类中的构造函数,对类进行初始化。

    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    class Person :

    #创建对象的时候执行
    def __init__(self):
    self.food = 'rice'

    def eat(self):
    print ('eat food: %s' %self.food)

    wangwu = Person()

    wangwu.eat()

    输出:

    eat food: rice

    _ init() _ 方法参数

    类似java中带参的构造函数

    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    class Person :

    #含参数
    def __init__(self,food):
    self.food = food

    def eat(self):
    print ('eat food: %s' %self.food)

    #调用的时候传参
    wangwu = Person('noodle')

    wangwu.eat()

    输出:

    eat food: noodle


    理解self

    字面理解:自己的意思,类似java中的this关键字。

    其实可以写成其他任意名字,比如this,temp,使用self我觉得是一种规范吧。

    至于为啥不隐藏呢,主要体现语言设计者的品味。

    打印self看一下:

    1
    2
    3
    4
    5
    6
    7
    8
    class Test :

    def test(self):
    print self

    t = Test()
    t.test()
    print t

    输出:

    <__main__.test instance="" at="" 0x0000000002322a88="">

    <__main__.test instance="" at="" 0x0000000002322a88="">

    代表当前对象的地址。


    _ str _方法

    python中有许多有意思的魔法方法,当使用print输出对象的时候,如果定义了_ str _(self)方法,则打印该方法return的数据。

    1
    2
    3
    4
    5
    6
    class Test :
    def __str__(self):
    return "hello world"

    t = Test()
    print t # 打印的是__str__返回的内容

    输出:

    hello world


    私有属性

    属性前加双下划线 为私有属性

    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
    15
    16
    17
    18
    19
    20
    21
    class Test :
    def __init__(self,num1,num2):
    self.__num1 = num1 #私有属性,外部无法修改
    self.num2 = num2 #共有属性,外部可以修改

    def __str__(self):
    return "num1: " + str(self.__num1) + " num2: "+str(self.num2)

    def setNum(self,newNum):
    self.__num1 = newNum #内部可以修改类中的私有属性


    t = Test(10,100)
    print t

    t.__num1 = 20 #外部设置类中的私有属性,无效
    t.num2 = 200
    print t

    t.setNum(20)
    print t

    输出:

    num1: 10 num2: 100
    num1: 10 num2: 200
    num1: 20 num2: 200

    私有方法

    跟私有属性一样,前面加两个下划线为私有方法

    1
    2
    3
    class Test:
    def __privateMethod(self):#私有方法
    print "private method"
    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    class Animal :

    def __privcateTest(self):
    print ("private method")

    def printinfo(self):#内部访问私有方法
    self.__privcateTest()


    animal = Animal()
    animal.printinfo()
    animal._Animal__privcateTest() #调用的时候,python解析器把所有以双下划线开头的方法翻译成_类名__私有方法的形式。

    输出:

    private method
    private method


    _ del _()方法

    创建对象时,python的解释器默认调用_ init 方法。
    当删除一个对象时,python的解释器也会调用一个方法,这个方法就是
    del _方法。

    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
    class Test :
    def __init__(self):
    print ("----python init ----")


    def __str__(self):
    return "I'm python"

    def __del__(self):
    print ("----python del ----")

    t = Test()
    print t
    print "python go go go"

    输出:

    —-python init —-
    I’m python
    python go go go
    —-python del —-

    python解释器,如果检测一个对象没有任何用处了,则把该对象回收掉。

    这里的回收主要是使用引用计数法,当该对象的引用数为0的时候,会执行del方法。

    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
    15
    16
    17
    18
    19
    20
    21
    22
    23
    24
    25
    26
    27
    28
    29
    30
    class Test :
    def __init__(self):
    print ("----python init ----")

    def __str__(self):
    return "I'm python"

    def __del__(self):
    print ("----python del ----")

    t = Test()
    t1 = t
    t2 = t
    t3 = t

    print ("------1-------")

    del t

    del t1

    print ("------2-------")

    del t2

    print ("------3-------")

    del t3 #对象的引用数为0

    print ("------4-------")

    输出:

    —-python init —-
    ——1——-
    ——2——-
    ——3——-
    —-python del —-
    ——4——-


    继承

    与java一样,python也有继承。

    class 子类名(父类名):
    …..

    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
    15
    class Animal :

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


    class Dog(Animal) : #继承Animal类

    def printInfo(self):
    print self.name,self.age


    littleDog = Dog ("xiaogougou","2")
    littleDog.printInfo()

    输出:

    xiaogougou 2

    需要注意:父类的私有属性和私有方法无法被继承。

    重写

    子类中有一个和父类相同名字的方法,在子类中的方法覆盖掉父类中同名的方法。

    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
    class Parent(object):
    def test(self):
    print "parent method"

    class Children(Parent):
    def test(self):

    print "Children method"
    Parent.test(self) #子类中调用父类方法,通过类名.方法名 super(Children,self).test()#子类中调用父类方法,通过super方式



    child = Children()
    child.test()

    输出:

    Children method
    parent method
    parent method

    多继承

    python跟C++一样,支持多继承。

    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
    class Class1(object):
    def test1(self):
    print "test1"

    class Class2(object):
    def test2(self):
    print "test2"

    class Class3(Class1,Class2): #继承Class1,Class2
    pass

    class3 = Class3()
    class3.test1()
    class3.test2()

    输出:

    test1
    test2

    若父类中有相同名称的方法,就近调用。

    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
    class Class1(object):
    def test(self):
    print "test1"

    class Class2(object):
    def test(self):
    print "test2"

    class Class3(Class1,Class2):#Class1,Class2 中都有test方法,就近找Class1中的test
    pass

    class3 = Class3()
    class3.test()
    print (Class3.__mro__)# 打印调用关系

    输出:

    test1
    (, , , )


    多态

    相对于java的多态,python的多态更像是一种思想。

    也可以简单理解为不同的类中有相同名称的函数,通过调用这些相同名称的函数来实现不同功能。

    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
    15
    16
    17
    18
    19
    20
    21
    22
    23
    class Animal(object):
    def eat(self):
    print "Animal eat"

    class Dog(Animal):
    def eat(self):
    print "Dog eat"

    class Cat(Animal):
    def eat(self):
    print "Cat eat"


    def eat(temp):
    temp.eat()#这个就是多态的表现形式

    animal = Animal()
    dog = Dog()
    cat = Cat()

    eat(animal)
    eat(dog)
    eat(cat)

    输出:

    Animal eat
    Dog eat
    Cat eat


    类方法

    python中的类方法类似java中的static方法,可以直接用类名.方法名调用。

    在方法名上加@classmethod注解即可

    class A(object):

    address = "shandong"
    
    @classmethod #类方法
    def aa(cls):
        cls.address = "beijing"
    

    A.aa() #类名直接调用
    print A.address


    输出:

    beijing


    异常

    try:
    ….
    except ErrorType as message:
    ….
    else:
    ….#如果没有捕获异常,则执行
    finally: #一定会执行

    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    try:
    print "-------begin-------"
    open("123.txt",'r')
    print "-------end-------"
    except IOError as message:
    print "error"
    print message
    else:#没有异常的话,执行下面的
    print "no exception"
    finally:#一定执行
    print "close"

    输出:

    ——-begin——-
    error
    [Errno 2] No such file or directory: ‘123.txt’
    close


    抛出异常

    python使用raise关键字抛出异常,类似java的throw

    demo: 自定义一个异常,手动抛出。

    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
    15
    16
    17
    18
    19
    20
    21
    22
    23
    24
    #自定义异常类
    class myException(Exception):

    def __init__(self,mesg):
    Exception.__init__(self)
    print "define my exception"
    self.mesg = mesg



    try:
    print "-------begin-------"
    raise myException("I'm exception") #手动抛出异常
    print "-------end-------"
    except IOError as message:
    print "error"
    print message
    except myException,x:#x变量绑定到异常实例
    print "myException"
    print x.mesg
    else:
    print "no exception"
    finally:
    print "close"

    输出:

    ——-begin——-
    define my exception
    myException
    I’m exception
    close