第三周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
c22c
= 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()