第三周python面向对象学习总结

这周主要学习了面向对象，了解面向对象的用法，何为对象呢，生活中一切皆为对象，编程就是将生活中要解决的事用程序语言表达出来，如果会灵活运用面向对象，一切将会变得非常容易。我把我学到的做以分享。

了解面向对象

1，面向过程的编程是以函数为核心的，而面向对象的编程是以类为核心的，一切功能的实现，都是通过创建一个司职该功能的类的实例，进而调用其方法去予以实现的；
2，以类为核心的、面向对象的编程，提高了代码的模块化程度，便于大规模协作的开展；
3，现如今的高级语言，基本都是面向对象的；
4，面向对象的三大特性：封装、继承、多态；
5，继承 - 从已经有的类创建新类的过程
6，提供继承信息的称为父类(超类/基类)
7，得到继承信息的称为子类(派生类/衍生类)
8，通过继承我们可以将子类中的重复代码抽取到父类中
9，子类通过继承并复用这些代码来减少重复代码的编写
10， 将来如果要维护子类的公共代码只需要在父类中进行操作即可
可以通过具体的代码了解

class Person(object):
    def __init__(self, name, age):
        self._name = name
        self._age = age
    def watch_av(self):
        if self._age >= 18:
            print('%s正在看片.' % self._name)
        else:
            print('%s只能看《熊出没》.' % self._name)
class Student(Person):

   def __init__(self, name, age, grade):
       super().__init__(name, age)
       self._grade = grade
   def study(self, course):
       print('%s的%s正在学习%s.' % (self._grade, self._name, course))
class Teacher(Person):

    def __init__(self, name, age, title):
        super().__init__(name, age)
        self._title = title
    def teach(self, course):
        print('%s%s正在讲%s.' % (self._name, self._title, course))
def main():
    stu = Student('二狗', 15, '初三')
    stu.study('英语')
    stu.watch_av()
    t = Teacher('老万', 45, '叫兽')
    t.teach('爬虫')
    t.watch_av()
if __name__ == '__main__':
    main()

了解property包装器

1，使用property装饰器将方法转为属性
关键字参数 - 字典 - 根据参数名来决定如何执行
可变参数 - 元组
命名关键字参数
decorator - 装饰器 / 包装器

通过一个定义一个矩形的对象求它的周长和面积具体了解

class Rect(object):

    def __init__(self, width=0, height=0):
        self._width = width
        self._height = height

    @property
    def width(self):
        return self._width

    @width.setter
    def width(self, width):
        self._width = width if width > 0 else 0

    @property
    def height(self):
        return self._height

    @height.setter
    def height(self, height):
        self._height = height if height > 0 else 0

    @property
    def area(self):
        return self._width * self._height

    @property
    def perimeter(self):
        return (self._width + self._height) * 2


def main():
    rect = Rect(3, 5)
    print(rect.area)
    print(rect.perimeter)
    rect.width = 20
    rect.height = 3.5
    print(rect.area)
    print(rect.perimeter)


if __name__ == '__main__':
    main()

了解类方法和静态方法

1，通常在类中定义一个方法时，系统都会默认带上一个self参数，这样的方法称之为实例方法；
2，实例方法也就是，只有通过创建类的实例才能访问的方法；
3，静态方法以@staticmethod装饰器进行装饰，它相当于一个写在类的作用域中的普通方法；
4，类方法以@classmethod装饰器进行装饰，它有一个系统默认参数cls，代表的是当前类，我 们可以通过这个cls()去创建一个类的实例；

已知三条边，判定能否构成三角形，然后求周长和面积

class Triangle(object):

    def __init__(self, a, b, c):
        self._a = a
        self._b = b
        self._c = c

    # @classmethod
    # def is_valid(cls, a, b, c):
    @staticmethod
    def is_valid(a, b, c):
        # print(cls)
        # print(type(cls))
        return a + b > c and b + c > a and a + c > b

    def perimeter(self):
        return self._a + self._b + self._c

    def area(self):
        half = self.perimeter() / 2
        return sqrt(half * (half - self._a) *
                    (half - self._b) * (half - self._c))


def main():
    a = 3
    b = 4
    c = 5
    if Triangle.is_valid(a, b, c):
        t = Triangle(a, b, c)
        print(t.perimeter())
        print(Triangle.perimeter(t))
        print(t.area())
        print(Triangle.area(t))
    else:
        print('无法构成三角形.')

练习1计算员工工资结算

class Employee(object):
    '''员工工资'''

    def __init__(self,name):
        self._name=name


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

    def get_salary(self):
        '''
        获得月薪
        :return: 返回结果
        '''
        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,sales=0):
        super().__init__(name)
        self._sales=sales

    @property
    def sales(self):
        return self._sales

    @sales.setter
    def sales(self,sales):
        self._sales=sales if sales>0 else 0

    def get_salary(self):
        return 1200.0+self._sales*0.05




def main():
    emps=[
        Manager('刘备'),Programmer('诸葛亮'),
        Manager('曹操'),Salesman('荀彧'),
        Salesman('吕布'),Programmer('张辽'),
        Programmer('赵云')
    ]
    for emp in emps:

        if isinstance(emp,Programmer):
            emp.working_hour=int(input('请输入%s本月工作时间:' % emp.name))

        elif isinstance(emp,Salesman):
            emp.sales=float(input('请输入%s本月销售额:'% emp.name))

            #同样是接受get_salary这个消息  但是不同的员工表现出不同的行为
            #因为三个子类都重写了get_salary方法  所以这个方法会表现出多态行为
        print('%s本月工资为:￥%.2f元' %
              (emp.name,emp.get_salary()))

if __name__ == '__main__':
    main()

练习2 五子棋游戏

#五子棋游戏

import pygame

EMPTY = 0
BLACK = 1
WHITE = 2

black_color = [0, 0, 0]
white_color = [255, 255, 255]


class RenjuBoard(object):

    def __init__(self):
        self._board = [[]] * 15
        self.reset()

    def reset(self):
        for row in range(len(self._board)):
            self._board[row] = [EMPTY] * 15

    def move(self, row, col, is_black):
        if self._board[row][col]==EMPTY:
            self._board[row][col] = BLACK if is_black else WHITE
            return True
        return False

    def draw(self, screen):
        for index in range(1, 16):
            pygame.draw.line(screen, black_color,
                             [40, 40 * index], [600, 40 * index], 1)
            pygame.draw.line(screen, black_color,
                             [40 * index, 40], [40 * index, 600], 1)
        pygame.draw.rect(screen, black_color, [36, 36, 568, 568], 4)
        pygame.draw.circle(screen, black_color, [320, 320], 5, 0)
        pygame.draw.circle(screen, black_color, [160, 160], 5, 0)
        pygame.draw.circle(screen, black_color, [480, 480], 5, 0)
        pygame.draw.circle(screen, black_color, [480, 160], 5, 0)
        pygame.draw.circle(screen, black_color, [160, 480], 5, 0)
        for row in range(len(self._board)):
            for col in range(len(self._board[row])):
                if self._board[row][col] != EMPTY:
                    ccolor = black_color \
                        if self._board[row][col] == BLACK else white_color
                    pos = [40 * (col + 1), 40 * (row + 1)]
                    pygame.draw.circle(screen, ccolor, pos, 20, 0)


def main():
    board = RenjuBoard()
    is_black = True
    pygame.init()
    pygame.display.set_caption('五子棋')
    screen = pygame.display.set_mode([640, 640])
    screen.fill([255, 255, 0])
    board.draw(screen)
    pygame.display.flip()
    running = True
    while running:
        for event in pygame.event.get():
            if event.type == pygame.QUIT:
                running = False
            elif event.type == pygame.KEYUP:
                pass
            elif event.type == pygame.MOUSEBUTTONDOWN \
                    and event.button == 1:
                x,y = event.pos
                row =round ((y-40)/40)
                col = round((x-40)/40)
                if board.move(row,col,is_black):
                    is_black = not is_black
                    screen.fill([255, 255, 0])
                    board.draw(screen)
                    pygame.display.flip()

    pygame.quit()


if __name__ == '__main__':
    main()