python第三周学习总结
- 在本周的学习过程中，我们主要学习了函数和面向对象编程，并伴随了大量的练习来巩固这部分关键知识，同时这部分内容也是作为考试的重点来进行考试。
函数
- 概念：函数是组织好的，用来实现单一，或相关功能的代码段
- 参数：函数调用时需要参数，主要分为，默认值参数，可变参数，关键字参数，命名关键字参数
默认参数：调用函数时，如果没有传递参数，则使用默认值参数
可变参数：函数参数不定长的参数（args）
关键字参数：函数的调用者可以传入任意不受限制的关键字参数 kwages
命名关键字参数：关键字参数和函数调用关系紧密，函数调用使用关键字参数来确定传入的参数值(def foo( a, b, * , name, age))，和关键字参数kw不同，命名关键字参数需要一个特殊分隔符，*后面的参数被视为命名关键字参数
def foo(a, b, c, *, name, age):# *是分隔符，前面的参数爱给不给，后面的参数一定要给
print(a + b + c)
print(name, ':', age)
# 如果希望将一个字典作为关键字参数传入，需要在参数前放置 **
。（foo(**dict1)）
# 列表也是同理进行处理，放置一个 * 。(foo(*list1))
类和对象
- 面对对象编程要遵循以下法则：
1，单一职责原则：一个类只负责一项职责
2，开闭原则：对扩展开放，对修改关闭。
3，依赖倒转原则(x)：高层模块不应该依赖低层模块，二者都应该依赖其抽象；抽象不应该依赖细节；细节应该依赖抽象。它的核心是面向接口编程。,
4，里氏替换原则：子类可以扩展父类的功能，但不能改变父类原有的功能
接口隔离原则(x)：客户端不应该依赖它不需要的接口，一个类对另一个类的依赖应该建立在最小的接口上。（高内聚）
5，合成聚合复用原则：该原则就是在一个新的对象里面使用一些已有的对象，使之成为新对象的一部分：新的对象通过向这些对象的委派达到复用已有功能的目的。
6，迪米特法则(最少知识原则)：一个对象应该对其他对象保持最少的理解。（低耦合）
类和实例
- 1，概念：类是抽象的模板，而实例是根据类创建出来的一个个具体的“对象”，每个对象都拥有相同的方法，但各自的数据可能不同。
2，定义：class Student(object):
3，方法：方法就是与实例绑定的函数，和普通函数不同，方法可以直接访问实例的数据
4，构造函数：''init(self)''，又称初始化方法：init方法的第一个参数永远是self，表示创建的实例本身，因此，在init方法内部，就可以把各种属性绑定到self，因为self就指向创建的实例本身。
class Teacher(object):
def __init__(self, name , age, title):
self._name = name
self._age = age
self._title = title
5，数据封装：直接操作了对象内部的数据，但无需知道方法内部的实现细节
@property
def name(self):
return self._name
6，继承： 从已经有的类创建新类的过程
提供继承信息的称为父类（超类/基类， 得到继承信息的称为子类（派生类/衍生类）。通过继承我们可以讲子类中的重读代码抽取到父类中，子类通过继承并复用这些代码来减少重复代码的编写，将来如果要维护子类的公共代码只需要在父类中进行操作即可。
class Student(Person):
def __init__(self, name, age):
super().__init__(name, age) #调用父类方法
self._grade = grade
7，方法重写：子类在继承父类方法之后 对方法进行了重新实现
class Parent: # 定义父类
def myMethod(self):
print ('调用父类方法')
class Child(Parent): # 定义子类
def myMethod(self):
print ('调用子类方法')
c = Child() # 子类实例
c.myMethod() # 子类调用重写方法
super(Child,c).myMethod() #用子类对象调用父类已被覆盖的方法
8，装饰器：decorator
# 高阶函数 - f(g(x))
# 高内聚:一个函数只做好一件事，该做的是
# 低耦合：不要让你的代码根某种东西紧紧的绑定在一起
# high cohesion low coupling
#通过向函数中传入函数，可以写出更通用的代码
#calc函数中的第二个函数是另一个函数，它代表了一个二元函数
#这样calc函数就不需要根某一种特定的二元运算耦合在一起```
def calc(my_list, op):
total = my_list[0]
for index in range(1, len(my_list)):
total += my_list[index]
return total
def add(x, y):
return x + y
def mul(x, y):
return x * y
def main():
my_list = [2, 3, 4, 5, 6]
print(calc(my_list, add))
if __name__ == '__main__':
main()
实例
- 主要以奥特曼打怪兽和基于pygame开发的贪吃蛇来练习面对对象编程
- 工资结算系统：部门经理：固定月薪 1W5 ； 程序员； 1h = 150元 销售员： 1200底薪 + 销售额 %5 的提成
from abc import abstractmethod# abc模块中还有一个包装器abstractmethod
# 通过这个包装器可以将方法包装为抽象方法 必须要求子类进行重写
class Employee(object):
def __init__(self, name):
self._name = name
@property
def name(self):
return self._name
@abstractmethod
def get_salary(self):
pass
class Manager(Employee):
def get_salary(self):
return 15000.0
class Programmer(Employee):
def __init__(self, name):
super().__init__(name) # 继承父类的方法
self._working_hour = 0
@property #包装器，装饰器
def working_hour(self):
return self._working_hour
@working_hour.setter #修改器
def working_hour(self, working_hour):
self._working_hour = working_hour if working_hour > 0 else 0
def get_salary(self):
return 150.0 * self._working_hour
class Salesman(Employee):
def __init__(self, name):
super().__init__(name)
self._sales = 0
@property
def sales(self):
return self._sales
@sales.setter
def sales(self, sales):
self._sales = self._sales if sales > 0 else 0
def get_salary(self):
return 1200 + self._sales * 0.05
def main():
emps = [
Manager('张三'), Programmer('李四'), Salesman('王五')
]
for emp in emps:
if isinstance(emp, Programmer):#是不是某种类型的实例
emp.working_hour = int(input('请输入%s的工作时间' % emp.name)) # 在这里使用修改器修改了父类的方法
if isinstance(emp, Salesman):
emp.sales = int(input('请输入%s的销售额' % emp.name))
#同样是调用get_salary的方法，但是不同的员工表现出了不同的行为
# 因为三个子类都重写了get_salary方法，所以，此处有多态行为 ***********
print('%s的工资为%.2f' % (emp.name, emp.get_salary()))
if __name__ == '__main__':
main()
- 奥特曼打怪兽：
