1.1

笔记：

1. 异常捕获

(1) 语法：

try：

   语句块

except 异常类型：

   处理语句

(2) 没有异常时执行：else：语句块

(3) 最终要执行的内容：finally：语句块

(4) 引发异常：raise

(5) 自定义异常类：继承BaseException类

练习：

 # 1.写一个递归函数,传入一个数字返回它的阶乘.
def test1(x):
    if x == 1:
        return 1
    else:
        return x*test1(x-1)
print(test1(7))

# 2.（1）创建一个叫做People的类：
#
# 属性：姓名、年龄、性别、身高
#
# 行为：说话、计算加法、改名
#
# 编写能为所有属性赋值的构造方法；
class people:
    def __init__(self,name,age,sex,height):
         self.name 

 = name
        self.age = age
        self.sex = sex
        self.height = height
    def talk(self):
        print('你好！我的名字是：{0}，我的年龄是：{1}，我的性别是：{2}，我的身高是：{3}'.format(
             self.name 

,self.age,self.sex,self.height
        ))
    def add(self,a,b):
        print(a+b)
    def setname(self,sname):
         self.name 

 = sname
# （2）创建主类：
#
# 创建一个对象：名叫“张三”，性别“男”，年龄18岁，身高1.80；
#
# 让该对象调用成员方法：
#
# 说出“你好！”
#
# 计算23+45的值
#
# 将名字改为“李四”
zs = people('张三','男',18,'1.80')
zs.talk()
zs.add(23,45)
zs.setname('李四')
print( zs.name 

)
# 3.有两个序列a,b，大小都为n,序列元素的值任意整形数，无序；
# 要求：通过交换a,b中的元素，使[序列a元素的和]与[序列b元素的和]之间的差最小。
a = [1,1,1,1,2]
b = [2]
c = a+b
temp1 = []
temp2 = []
mint1 = []
mint2 = []
sum1 =0
sum2 = 0
minsum = 1000
for i in range(0,a.__len__()+1):
    for j in range(0,b.__len__()+1):
        temp1 = a[0:i]+b[0:j]
        temp2 = b[j:]+a[i:]
        for i in temp1:
            sum1 +=i
        for j in temp2:
            sum2 +=j
        if abs(sum1-sum2)<minsum:
            minsum = abs(sum1-sum2)
            mint1 = temp1
            mint2 = temp2
        sum1,sum2 = 0,0
print('差值最小的为：',mint1,mint2)

# 4.任意输入年月日，计算出这是这一年的第几天
import datetime
while True:
    date = input('请输入日期（格式：年-月-日）：')
    try:
        d1 = datetime.datetime.strptime(date,'%Y-%m-%d')
        break
    except ValueError:
        print('输入错误！')
d2 = date[:4]+'-1-1'
d2 = datetime.datetime.strptime(d2,'%Y-%m-%d')
print((d1-d2).days)
# 5.请定义一个函数 ’quadratic(a,b,c)‘，接收三个参数，返回一元二次方程:
# ax² + bx + c = 0 的两个解。（提示：计算平方根可以调用math.sqrt()函数）
# x=[-b±√(b²-4ac)]/2a (-b+math.sqrt(dt)/2*a,(-b-math.sqrt(dt)/2*a
import math
def quadratic(a,b,c):
    dt = b**2-4*a*c
    if dt>0:
        a1 = (-b+math.sqrt(dt)/(2*a))
        a2 = (-b-math.sqrt(dt)/(2*a))
        print('方程有两个解：{0}，{1}'.format(a1,a2))
    elif dt == 0:
        print('方程有一个解：',(-b)/2*a)
    else:
        print('方程没有解！')
quadratic(4,0,-1)

Python设计模式——装饰模式（Decorator）

假如我们需要开发一个程序来展示一个人穿衣服的过程。

#encoding=utf-8
__author__ = 'kevinlu1010@qq.com'
class Person():
    def __init__(self,name):
        print '%s开始穿衣'%name
    def wear_tshirt(self):
        print '穿TShirst'
    def wear_trouser(self):
        print '穿裤子'
    def wear_shoe(self):
        print '穿T鞋子'
    def wear_tie(self):
        print '穿领带'

if __name__=='__main__':
    person=Person('kevin')
    person.wear_shoe()
    person.wear_tie()
    person.wear_trouser()

这样写无疑是最快的，代码最简洁的，但是扩展性比较差，例如客户要求我们增加一个穿袜子的动作，我们就需要修改Person类，但是根据封闭-开发原则中的封闭原则，一个类写完之后是尽量不要修改它的，所以我们就需要另外一种实现方式

#encoding=utf-8
__author__ = 'kevinlu1010@qq.com'

from abc import ABCMeta, abstractmethod
class Person():
    def __init__(self, name):
        print '%s开始穿衣' % name

class Finery():
    __metaclass__ = ABCMeta
    @abstractmethod
    def show(self):
        pass
class TShirt(Finery):
    def show(self):
        print '穿TShirst'


class Trouser(Finery):
    def show(self):
        print '穿裤子'


class Shoe(Finery):
    def show(self):
        print '穿鞋子'


class Tie(Finery):
    def show(self):
        print '穿领带'


if __name__ == '__main__':
    person = Person('kevin')
    finerys=[]
    finerys.append(TShirt())
    finerys.append(Trouser())
    finerys.append(Shoe())
    finerys.append(Tie())
    map(lambda x:x.show(),finerys)

首先定义一个积累Finery,定义一个抽象方法show,然后每一个穿衣动作都写一个类，重写show方法。

如果客户修改需求，我们就新增加一个类就可以了。

 装饰模式的做法：

#encoding=utf-8
__author__ = 'kevinlu1010@qq.com'

from abc import ABCMeta, abstractmethod


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

    def decorator(self, component):
        self.component = component

    def show(self):
        print '%s开始穿衣' % self.name
        self.component.show()


class Finery():
    def __init__(self):
        self.component = None

    def decorator(self, component):
        self.component = component

    __metaclass__ = ABCMeta

    @abstractmethod
    def show(self):
        if self.component:
            self.component.show()


class TShirt(Finery):
    def show(self):
        Finery.show(self)
        print '穿TShirst'


class Trouser(Finery):
    def show(self):
        Finery.show(self)
        print '穿裤子'


class Shoe(Finery):
    def show(self):
        Finery.show(self)
        print '穿鞋子'


class Tie(Finery):
    def show(self):
        Finery.show(self)
        print '穿领带'


if __name__ == '__main__':
    person = Person('kevin')
    tshirt = TShirt()
    trouser = Trouser()
    shoe = Shoe()
    tie = Tie()

    trouser.decorator(tshirt)
    shoe.decorator(trouser)
    tie.decorator(shoe)
    person.decorator(tie)
    person.show()

每个类都有show方法，衣服类都有decorator方法，利用这个方法，动态地把不同衣服的show方法装饰到person这个类上，这样做一方面可以令person类更为精简，因为在实际应用中Person类可能会有很多方法，而穿衣服这个需求只是其中一个，另一方面是，增加Person类的可扩展性，例如如果Person类已经写好了，现在新的需求需要在某一次调用Person类的show方法的时候增加穿衣服的功能，这种模式就能很好地实现了。