两大对小白的难题函数和对象。首先对不住大家了在上周对函数的介绍没有补充完整，这周先补充一下函数的知识点。
参数分类
默认参数 在写函数的时候直接给参数默认一个值，在没有赋予其他的值得时候，按照默认值来执行程序
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
类和对象
类是抽象的，对象是具体概念
单一原则
单一职责原则的定义是就一个类而言，应该仅有一个引起他变化的原因。也就是说一个类应该只负责一件事情
高类聚
开闭原则
对于代码拓展开发，随便你怎么取然后去脱站，但是要修改原来本身已经定义好的就关闭。当需求发生改变的时候，我们需要对代码进行修改，这个时候我们应该尽量去扩展原来的代码，而不是去修改原来的代码，因为这样可能会引起更多的问题。
里氏替换原则
用子类对象去替换掉一个父类对象，这是面向对象编程中一个常见的行为
合成聚合复用原则
合成/聚合复用原则经常又叫做合成复用原则。该原则就是在一个新的对象里面使用一些已有的对象，使之成为新对象的一部分：新的对象通过向这些对象的委派达到复用已有功能的目的
如果能使用强关联的，就不要考虑继承
