对面向过程和面向对象两种编程方法我个人也是在探索过程，下面分享自己一些理解，如果有错误请指正。
1、面向过程：按照步骤一步步完成。
2、面向对象：按照功能，通过对象协作完成。
一、面向过程
1.程序结构
看到业务描述，按照动词来分配函数按照步骤编写程序，属于面向过程编程思维。可以采用动词法，
动词法：关注业务描述出现的动词，把它们列举出来，按步骤排列起来，画出流程图。
2.举例分析
举例：实现在图书馆借一本的《pythone编程基础》书。
程序步骤描述如下：
1、初始化信息-init
2、找到《pythone编程基础》-check
3、借阅《pythone编程基础》-borrow
3.程序实现分析
动词法：查找check、借borrow找到程序运行的定义需要函数
变量：
学生（学号、姓名）
书（书号、书名）
书库(书号、书名、存量)
借阅记录（书号、书名、借阅人学号、借阅人姓名）
伪代码,代码贴在后边。
import copy
student = [] # 学生信息列表
book_list = [] # 书
book_list_check = [] # 查询返回书单
book_lend_info = [] # 借阅记录
def init():
book_list.append(['1', 'python基础', 3])
book_list.append(['2', 'python高阶编程', 3])
book_list.append(['3', 'C语言编程基础', 1])
book_list.append(['4', 'JAVA编程基础', 2])
student.append(['1234', '张三'])
def check(book_name):
def borrow(book_sn, student_sno, student_name):
if __name__ == '__main__':
init()
i = 1
while i < 7:
bookname = str(input("输入书名："))
if check(bookname):
bsn = str(input("输入借阅编号："))
borrow(bsn, student[0][0], student[0][1])
i = i + 1
student = []
book_list_check = []
book_list = []
book_lend_info = []
二、面向对象
看到业务描述按照名词抽象为对象，找出对象属性和功能，按照对象相互关系编写类，属于面向过程思维，采用是名词法。
名词法：我们关注业务描述出现的名称，把它们列举出来，找出本身属性和功能，抽象把对象之间关系画类结构图和关系图。
1.类结构
2.举例分析
面向对象是通过对象协作实某个功能。
面向对象是根据对象本身的功能，组织他们，完成任务。
类定义：
1、学生类（学号、姓名）
2、书类（书号、书名）
3、借阅记录类（书号、书名、借阅人学号、借阅人姓名）
4、图书馆类（书、借阅记录）
类的功能：这里不复杂化，仅实现借书功能（使用面向对象优势就是扩展能力强）。
功能：查找书、办理借书和办理还书功能。
三、代码（仅作参考）
1.面向过程实现（仅作参考）
import copy
student = [] # 学生信息列表
book_list = [] # 书
book_list_check = [] # 查询返回书单
book_lend_info = [] # 借阅记录
def check(book_name):
# 根据输入的书名，查到打印查找记录，返回真值
print("查找：{} 相关书名".format(book_name))
for b in book_list:
if book_name in b[1]:
print("找到书号：{}".format(b[0]), end=" ")
print("找到书号：{}".format(b[1]), end=" ")
print("找到书号：{}".format(b[2]), end=" ")
print()
book_list_check.append(b)
# 添加查找到书列表
if not book_list_check:
# 书列表为空则打出错误信息，返回假值
print("未查到：{} 相关书名".format(book_name))
return False
else:
return True
def borrow(book_sn, student_sno, student_name):
# 根据输入的书号，借出、登记并打印所有借阅记录
index = False
for book in book_list:
if book_sn == book[0]:
book[2] = book[2] - 1
temp = copy.deepcopy(book) # 深拷贝复制书信息
temp.pop(2)
temp.append(student_sno)
temp.append(student_name)
book_lend_info.append(temp) # 登记，即增加借阅记录
index = True
print("办理借阅《{}》".format(book[1]))
i = 1
if book_lend_info:
# 如果借阅列表不为空，则打印图书馆所有借阅记录
for lend_info in book_lend_info:
print("借阅记录{}:".format(i))
print("书号:{}".format(lend_info[0]))
print("书名:《{}》".format(lend_info[1]))
print("借阅人学号:{}".format(lend_info[2]))
print("借阅人姓名:{}".format(lend_info[3]))
print()
i = i + 1
return index
def init(): # 初始化基础数据图书馆书库和学生
book_list.append(['1', 'python基础', 3])
book_list.append(['2', 'python高阶编程', 3])
book_list.append(['3', 'C语言编程基础', 1])
book_list.append(['4', 'JAVA编程基础', 2])
student.append(['1234', '张三'])
if __name__ == '__main__':
init()
i = 1
while i < 7:
bookname = str(input("输入书名："))
if check(bookname):
bsn = str(input("输入借阅编号："))
borrow(bsn, student[0][0], student[0][1])
i = i + 1
2.面向对象实现（仅作参考）
class Book:
def __init__(self, book_sn, book_title, book_position, book_count):
self.book_sn = book_sn
self.book_title = book_title
self.book_position = book_position
self.book_count = book_count
class Student:
def __init__(self, student_stn, student_name):
self.student_stn = student_stn
self.student_name = student_name
class InfoLoaner:
def __init__(self, book_sn, book_title, student_stn, student_name):
self.book_sn = book_sn
self.book_title = book_title
self.student_stn = student_stn
self.student_name = student_name
from Book import Book
from InfoLoaner import InfoLoaner
class Library:
library_books = [] # 图书馆藏书
library_lend_list = [] # 借书名单
def __init__(self):
b1 = Book(1, 'C语言设计', 'C类别1号架', 3)
b2 = Book(2, 'python基础', 'P类别2号架', 3)
b3 = Book(3, '数据结构', 'D类别2号架', 3)
b4 = Book(4, 'python高阶', 'P类别2号架', 1)
self.library_books.append(b1)
self.library_books.append(b2)
self.library_books.append(b3)
self.library_books.append(b4)
def check(self, title):
# 根据书名查找书，找不到，返回假；找到，打印书列表
print("start------Library.check------")
book_list = []
for b in self.library_books:
if title in b.book_title:
book_list.append(b)
if not book_list:
print("未查到 {} 相关的书籍".format(title))
print("end ------Library.check------")
return False
else:
for bl in book_list:
print("根据书名找到:")
print("书号:{}".format(bl.book_sn), end=" ")
print("书名:{}".format(bl.book_title), end=" ")
print("位置:{}".format(bl.book_position), end=" ")
print("存量:{}".format(bl.book_count), end=" ")
print()
print("end ------Library.check------")
return True
def lend(self, book_sn, student_stn, student_name):
# 根据书号，登记借阅信息，并打印当前记录。（待补充完善，打印当前人所有借阅记录）
print("start------Library.lend------")
for b in self.library_books:
if b.book_sn == book_sn:
b.book_count -= 1
info1 = InfoLoaner(b.book_sn, b.book_title, student_stn, student_name)
self.library_lend_list.append(info1)
print("书号:{}".format(info1.book_sn), end=" ")
print("书名:{}".format(info1.book_title), end=" ")
print("借阅人学号:{}".format(info1.student_stn), end=" ")
print("借阅人姓名:{}".format(info1.student_name), end=" ")
print()
print("end ------Library.lend------")
return b
return None
def return_book(self, title):
# 待补充，要实现 增加图书馆书本存量，并删除借阅记录
for b in self.library_books:
if b.title == title:
b.count += 1
return b
return None
from Library import Library
from Student import Student
if __name__ == '__main__':
li = Library()
st = Student(1234, "张三")
while True:
book_title = str(input("书名："))
if li.check(book_title):
book_sn = int(input("输入需要借阅书号："))
li.lend(book_sn, st.student_stn, st.student_name)
总结
面向对象觉得没讲完，不能体现面向对象的强大扩展能力，容易维护和复杂性，其中封装性、继承、多态、设计模式都是面向对象的最重要内容，这里仅仅是从面向过程到面向对象思维转化一点点心得体会。
心得1：面向对象一个思维问题，不仅仅是编程问题，不同人可以有不同产生不同的类和类结构和类关系。
心得2：练习面向对象这种抽象思维，从更高层面上把控整个设计，面向过程则很难做到，几乎从头到尾顺序下来编程，面向对象思维，就是把整个项目解构了，按照设计原则多人合作完成编码，效率自然大大提高。
心得3：多练习编程，熟练度提高，过段时间就会觉得编程还是很简单，毕竟学了教员实践论和矛盾论，高屋建瓴看待所有事务，思路也特别清晰。
646
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
