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()

• 奥特曼打怪兽：