两大对小白的难题函数和对象。首先对不住大家了在上周对函数的介绍没有补充完整，这周先补充一下函数的知识点。

参数分类

默认参数 在写函数的时候直接给参数默认一个值，在没有赋予其他的值得时候，按照默认值来执行程序

def pow(x, n = 2):

    r = 1
    while n > 0:
        r *= x
        n -= 1
    return r

注:必选参数必须在前面，默认参数在后

可以变参数和关键字参数 定义函数时，有时候我们不确定调用的时候会传递多少个参数，此时我们就可以使用可变参数来定义，后期需要几个我们就定义，一般是以元祖或者列表的形式呈现

*args argsFunc 中匹配完定义好的参数，剩余的参数以元组的形式存储在 args（args 名称你可以自行定义），因此在上述程序中只要你传入不小于 1 个参数，该函数都会接受，当然你也可以直接定义只接受可变参数，你就可以自由传递你的参数
*kwargs 形参名前加两个表示，参数在函数内部将被存放在以形式名为标识符的 dictionary 中，这时调用函数的方法则需要采用 arg1 = value1,arg2 = value2这样的形式

我把 args 称作为数组参数，*kwargs 称作为字典参数

下面举个例子给大家：

def say_hello(** kwargs):
    if 'name' in kwargs:
        print(' 你好，%s!'% kwargs['name'])
    elif 'age' in kwargs :
        age = kwargs['age']
        if age <= 16:
            print('你是一个小屁孩')
        else :
            print('你是一个成年人')
    else:
        print('请输入你的个人信息！')

def main():
    say_hello(name = '娜美',age = 16)
    param= {'name':'王大锤','age':'12','tel':'124567789'}
    # 如果想一个字典传为参数，需要在前面加上**
    say_hello(**param)
    #如果希望传入的是一个列表或者元祖，需要在前面加上*
    #my list = [1,2,3,4]
    #my_sum(*my_list)

if __name__ == '__main__':
    main()

命名关键字参数 参数中有* 存在，后面的传参数必须给参数名。如果要限制关键字参数的名字，就可以用命名关键字参数，例如，只接收city和job作为关键字参数。下面举个列子：

def foo ( a , b , c  , * , name , age):

    print(a + b + c)
    print(name,':',age)

调用方法

 foo('3, 2, 3, name='jack', age=25)

注：*不是参数，而是分隔符。如缺少*，python解释器将无法识别位置参数和命名关键字参数

对象

@property 修饰器，包装器 主要是解决权限问题。将属性命名以单下划线开头，通过修饰来暗示属性是受保护的，不建议外界直接访问

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

    @property
    def name(self):
        return self._name

    @name.setter
    def name(self, name):
        self._name = name


class Manager(Names):
    def __init__(self, name, month):
        super().__init__(name)
        self._month = month

    @property
    def month(self):
        return self._month

    @month.setter
    def month(self,month):
        self._month = month

    def m_money(self):
        print('%s经理工作%d个月得到工资:%d' % (self._name, self._month, self._month * 15000))


class Programmer(Names):
    def __init__(self, name, hour):
        super().__init__(name)
        self._hour = hour

    # getter - 访问器
    @property
    def hour(self):
        return self._hour

    # setter - 修改器
    @hour.setter
    def hour(self,hour):
        self._hour = hour

    def u_money(self):
        print('%s工程师工作%d小时得到工资：%d元' % (self._name, self._hour, self._hour * 150))


class Sale(Names):
    def __init__(self, name, sums):
        super().__init__(name)
        self._sums = sums

    @property
    def sums(self):
        return self._sums

    @sums.setter
    def sums(self, sums):
        self._sums = sums

    def s_money(self):
        print('%s销售人员销售金额%d,底薪加提成的工资：%d' % (self._name, self._sums, 1200 + self._sums * 0.05))


def main():
    m = Manager('关羽', 2)
    m.m_money()
    p = Programmer('刘备', 20)
    p.u_money()
    s = Sale('张飞', 8000)
    s.s_money()
    m1 = Manager('赵云', 5)
    m1.m_money()
    p2 = Programmer('曹操', 10000)
    p2.u_money()
    s1 = Sale('诸葛亮', 800000)
    s1.s_money()


if __name__ == '__main__':
    main()

slots 需要限定自定义类型的对象只能绑定某些属性，可以通过在勒种定义slot变量来进行限定，注意 slot只对当前类对象生效，对子类不起作用

类之间的关系

此处盗用老师图

image.png
image.png

类和对象

类是抽象的，对象是具体概念

单一原则

单一职责原则的定义是就一个类而言，应该仅有一个引起他变化的原因。也就是说一个类应该只负责一件事情
高类聚

开闭原则

对于代码拓展开发，随便你怎么取然后去脱站，但是要修改原来本身已经定义好的就关闭。当需求发生改变的时候，我们需要对代码进行修改，这个时候我们应该尽量去扩展原来的代码，而不是去修改原来的代码，因为这样可能会引起更多的问题。

里氏替换原则

用子类对象去替换掉一个父类对象，这是面向对象编程中一个常见的行为

合成聚合复用原则

合成/聚合复用原则经常又叫做合成复用原则。该原则就是在一个新的对象里面使用一些已有的对象，使之成为新对象的一部分：新的对象通过向这些对象的委派达到复用已有功能的目的

如果能使用强关联的，就不要考虑继承