《Python语言程序设计》,Python程序语言设计基础

　　这篇文章给大家带来了一些关于python的知识，主要梳理了一些编程思路相关的问题。Python是一种带有oop(面向对象编程)的脚本语言，编程思想的核心是理解函数逻辑。下面就来看看吧，希望对你有帮助。

1 基本的程序设计模式

2.1 自顶向下-分而治之

　　如果实现功能的逻辑比较复杂，就需要进行模块化设计,将复杂的问题分解成几个简单的问题，其中简单的问题可以进一步分解成更简单的问题，直到可以通过模块编程实现功能逻辑，这也是编程的自顶向下特性。摘要如下：

　　把一个一般问题表达成几个小问题的形式，用同样的方法进一步分解小问题，直到小问题可以用计算机简单明了地求解2.2 举例1：体育竞技分析。

2 解决复杂问题的有效方法：自顶向下（设计）

Print info()步骤1:打印程序的介绍信息

　　Getlnputs()步骤2:获取程序运行参数：proa，prob，n。

　　SimNGames()步骤：利用玩家A和b的能力值模拟N局游戏。

　　summary()的步骤4:输出玩家A和B赢得游戏的次数和概率。

　　00-1010 #导入python资源包

　　从随机导入随机

　　#用户体验模块

　　def printIntro():

　　Print(这个程序模拟两个玩家A和B之间的某种竞技比赛)

　　Print(程序运行需要A和B的能力值(用0到1之间的小数表示)

　　#获取A和b的能力值和会话模块。

　　def getIntputs():

　　A=eval(input(请输入A的能力值(0-1):))

　　B=eval(输入(请输入b的能力值(0-1):))

　　N=eval(输入(模拟匹配数：))

　　返回a，b，n

　　#模拟N场比赛模块

　　def simNGames(n，probA，probB):

　　winsA，winsB=0，0

　　对于范围(n):内的I

　　 scoreA, scoreB = simOneGame(probA, probB)

　　 if scoreA > scoreB:

　　 winsA += 1

　　 else:

　　 winsB += 1

　　 return winsA, winsB

　　# 判断比赛结束条件

　　def gameOver(a, b):

　　 return a == 15 or b == 15

　　# 模拟n次单局比赛=模拟n局比赛

　　def simOneGame(probA, probB):

　　 scoreA, scoreB = 0, 0

　　 serving = "A"

　　 while not gameOver(scoreA, scoreB):

　　 if serving == "A":

　　 if random() < probA:

　　 scoreA += 1

　　 else:

　　 serving = "B"

　　 else:

　　 if random() < probB:

　　 scoreB += 1

　　 else:

　　 serving = "A"

　　 return scoreA, scoreB

　　# 打印结果模块

　　def printSummary(winsA, winsB):

　　 n = winsA + winsB

　　 print("竞技分析开始，共模拟{}场比赛".format(n))

　　 print("选手A获胜{}场比赛，占比{:0.1%}".format(winsA, winsA / n))

　　 print("选手B获胜{}场比赛，占比{:0.1%}".format(winsB, winsB / n))

　　def main():

　　 printIntro()

　　 probA, probB, n = getIntputs() # 获得用户A、B能力值与比赛场次N

　　 winsA, winsB = simNGames(n, probA, probB) # 获得A与B的场次

　　 printSummary(winsA, winsB) # 返回A与B的结果

　　main()

2.2.3 测试结果

　　2.3 举例2：的斐波那契数列

　　自顶向下的方式其实就是使用递归来求解子问题，最终解只需要调用递归式，子问题逐步往下层递归的求解。

　　程序设计：

cache = {}
　　def fib(number):
　　 if number in cache:
　　 return cache[number]
　　 if number == 0 or number == 1:
　　 return 1
　　 else:
　　 cache[number] = fib(number - 1) + fib(number - 2)
　　 return cache[number]
　　if __name__ == '__main__':
　　 print(fib(35))

运行结果：

14930352
　　&gt;&gt;&gt;

理解自顶向下的设计思维：分而治之
　　

3 逐步组建复杂系统的有效测试方法：自底向上（执行）

3.1 自底向上-模块化集成

　　自底向上（执行）就是一种逐步组建复杂系统的有效测试方法。首先将需要解决的问题分为各个三元进行测试，接着按照自顶向下相反的路径进行操作，然后对各个单元进行逐步组装，直至系统各部分以组装的思路都经过测试和验证。

理解自底向上的执行思维：模块化集成
　　

自底向上分析思想：

任何时候栈中符号串和剩余符号串组成一个句型，当句柄出现在栈顶符号串中时，就用该句柄进行归约，这样一直归约到输入串只剩结束符、栈中符号只剩下开始符号，此时认为输入符号串是文法的句子，否则报错。

自底向上是⼀种求解动态规划问题的方法，它不使用递归式，而是直接使用循环来计算所有可能的结果，往上层逐渐累加子问题的解。在求解子问题的最优解的同时，也相当于是在求解整个问题的最优解。其中最难的部分是找到求解最终问题的递归关系式，或者说状态转移方程。
　　

3.2 举例：0-1背包问题

3.2.1 问题描述

你现在想买⼀大堆算法书，有一个容量为 V 的背包，这个商店⼀共有 n 个商品。问题在于，你最多只能拿 W kg 的东西，其中 wi 和 vi 分别表示第 i 个商品的重量和价值。最终的目标就是在能拿的下的情况下，获得最大价值，求解哪些物品可以放进背包。

　　对于每⼀个商品你有两个选择：拿或者不拿。

3.2.2 自底向上分析

⾸先要做的就是要找到“子问题”是什么。通过分析发现：每次背包新装进⼀个物品就可以把剩余的承重能力作为⼀个新的背包来求解，⼀直递推到承重为0的背包问题。

　　用 m[i,w] 表示偷到商品的总价值，其中 i 表示⼀共多少个商品，w 表示总重量，所以求解 m[i,w]就是子问题，那么看到某⼀个商品i的时候，如何决定是不是要装进背包，需要考虑以下：

该物品的重量大于背包的总重量，不考虑，换下⼀个商品；
该商品的重量小于背包的总重量，那么尝试把它装进去，如果装不下就把其他东西换出来，看看装进去后的总价值是不是更高了，否则还是按照之前的装法；
极端情况，所有的物品都装不下或者背包的承重能力为0，那么总价值都是0；

由以上的分析，可以得出m[i,w]的状态转移方程为：

m[i,w] = max{m[i-1,w], m[i-1,w-wi]+vi}
　　

3.2.3 程序设计

# 循环的⽅式，自底向上求解
　　cache = {}
　　items = range(1,9)
　　weights = [10,1,5,9,10,7,3,12,5]
　　values = [10,20,30,15,40,6,9,12,18]
　　# 最⼤承重能⼒
　　W = 4
　　def knapsack():
　　 for w in range(W+1):
　　 cache[get_key(0,w)] = 0
　　 for i in items:
　　 cache[get_key(i,0)] = 0
　　 for w in range(W+1):
　　 if w &gt;= weights[i]:
　　 if cache[get_key(i-1,w-weights[i])] + values[i] &gt; cache[get_key(i-1,w)]:
　　 cache[get_key(i,w)] = values[i] + cache[get_key(i-1,w-weights[i])]
　　 else:
　　 cache[get_key(i,w)] = cache[get_key(i-1,w)]
　　 else:
　　 cache[get_key(i,w)] = cache[get_key(i-1,w)]
　　 return cache[get_key(8,W)]
　　def get_key(i,w):
　　 return str(i)+','+str(w)
　　if __name__ == '__main__':
　　 # 背包把所有东西都能装进去做假设开始
　　 print(knapsack())

29
　　&gt;&gt;&gt;

推荐学习：python以上就是一起聊聊python程序设计思想的详细内容，更多请关注盛行IT软件开发工作室其它相关文章！

郑重声明：本文由网友发布，不代表盛行IT的观点，版权归原作者所有，仅为传播更多信息之目的，如有侵权请联系，我们将第一时间修改或删除，多谢。

1 基本的程序设计模式

2 解决复杂问题的有效方法：自顶向下（设计）

2.2.3 测试结果

3 逐步组建复杂系统的有效测试方法：自底向上（执行）

3.2.1 问题描述

3.2.2 自底向上分析

3.2.3 程序设计

相关文章阅读