zoukankan      html  css  js  c++  java
  • 代码复用 组合类型 计算生态

    代码复用

    函数定义

    函数定义:使用def语句
     def<name>(<parameters>):       
    <body>

    函数名<name>:可以是任何有效的python标识符;

    参数列表<parameterrs>:是调用函数时传递给它的值(可以由多个,一个,或者零个参数组成,当有多个参数时,各个参数用逗号分隔)。

    参数可以分为形参和实参:

    形式参数:定义函数时,函数名后面圆括号中的变量,简称“形参”。形参只在函数内部有效。

    实际参数:调用函数时,函数名后面圆括号中的变量,简称“实参”

    自定义函数:用户自己编写的

    系统自带函数:python内嵌的函数(如abs()、eval())、python标准库中的函数(如math库中的sqrt())、图形库中的方法(如myPoint.getX())等。

    使用函数的目的:降低编程的难度,代码重用;

    return语句:结束函数调用,并将结果返回给调用者。

    函数接口:返回值和参数。
    函数传递信息的主要途径:

    ​ 通过函数返回值的方式传递信息;

    ​ 通过参数传递信息;

    函数调用

    函数调用执行的四个步骤:

    ​ 调用程序在调用处暂停执行;

    ​ 函数的形参在调用时备赋值为实参;

    ​ 执行函数体;

    ​ 函数被调用结束,给出返回值。、

    函数可以使模块程序化:
    
    
     1 def createTable (pri,apr):
     2     #为每一年绘制星号的增长图
     3     for year in range(1,11):
     4         pri = pri * (1 + apr)
     5         print("%2d"%year,end = '')
     6         total = caculateNum(pri)
     7         print("*" * total)
     8     print("0.0k  2.5k  5.0k  7.5k  10.0k")
     9 def caculateNum(pri):
    10     #计算星号数量
    11     total = int(pri*4/1000.0)
    12     return total
    13 def main():
    14     print("This program plots the growth of a 10-year investment.")
    15     #输入本金和利率
    16     pri = eval(input("Enter the initial principal:"))
    17     apr = eval(input("Enter the annualized interest rate:"))
    18     #建立图表
    19     createTable(pri,apr)
    20 main()

    递归

    递归:函数定义中使用函数自身的方法。经典例子:阶乘

    阶乘的递归定义函数:
    1 def fact(n):
    2     if n == 0:
    3         return 1
    4     else:
    5         return n*fact(n-1)

    运行递归函数fact()计算阶乘:

    >>> fact(4)
    24
    >>> fact(10)
    3628800
    字符串反转定义函数:
    1 def reverse(s):
    2     if s == "":
    3         return s
    4     else:
    5         return reverse(s[1:])+s[0]

    运行结果:

    >>> reverse("Hello!")
    '!olleH'

    Turtle 库回顾:

    Turtle中的指令,形象而简单,他绘制的坐标轴以屏幕中心为原点。具体见1.28笔记。

    树的绘制算法设计
     1 from turtle import Turtle, mainloop
     2  
     3 def tree(plist, l, a, f):
     4     """ plist is list of pens
     5     l is length of branch   树枝长度
     6     a is half of the angle between 2 branches 角度
     7     f is factor by which branch is shortened
     8     from level to level."""
     9     if l > 5: #
    10         lst = []
    11         for p in plist:
    12             p.forward(l)#沿着当前的方向画画
    13             q = p.clone()#Create and return a clone of the turtle with same position, heading and turtle properties.
    14             p.left(a) #Turn turtle left by angle units
    15             q.right(a)# turn turtle right by angle units, nits are by default degrees, but can be set via the degrees() and radians() functions.
    16             lst.append(p)#将元素增加到列表的最后
    17             lst.append(q)
    18         tree(lst, l*f, a, f)
    19    
    20             
    21  
    22 def main():
    23     p = Turtle()
    24     p.color("green")
    25     p.pensize(5)      #p.setundobuffer(None)
    27     p.hideturtle() #Make the turtle invisible. It’s a good idea to do this while you’re in the middle of doing some complex drawing,
    28     #because hiding the turtle speeds up the drawing observably.
    29     #p.speed(10)
    30   #p.getscreen().tracer(1,0)#Return the TurtleScreen object the turtle is drawing on.
    31     p.speed(10)
    32     #TurtleScreen methods can then be called for that object.
    33     p.left(90)       # Turn turtle left by angle units. direction 调整画笔
    34  
    35     p.penup() #Pull the pen up – no drawing when moving.
    36     p.goto(0,-200)#Move turtle to an absolute position. If the pen is down, draw line. Do not change the turtle’s orientation.
    37     p.pendown()# Pull the pen down – drawing when moving. 
        #这三条语句是一个组合相当于先把笔收起来再移动到指定位置,再把笔放下开始画;否则turtle一移动就会自动的把线画出来
    38  
    39     #t = tree([p], 200, 65, 0.6375)
    40     t = tree([p], 200, 65, 0.6375)
    41      
    42 main()

    组合类型

    编码:信息从一种形式转化为另一种形式的过程。

    ASCII码、Unicode、UTF-8...

    Unicode:

    ​ 跨语言,跨平台进行文本转换和处理;

    ​ 对每种语言中字符设定统一且唯一的二进制编码;

    ​ 每个字符两个字节长;

    ​ 65536个字符的编码空间;

    ​ “严”:Unicode的十六进制数为4E25;

    UTF-8编码:

    ​ 可变长度的Unicode的实现方式;

    ​ “严”:十六进制数为E4B8A5;

    Unicode与UTF-8编码字节范围对应关系:

    GBK编码:

    ​ 双字节编码

    文件:存储在外部介质上的数据或信息的集合。

    文本文件:以ASCII码方式存储文件。
    打开文件:open()

    ​ 建立磁盘上的文件与程序中的对象相关联;

    ​ 通过相关的文件对象获得;

    打开模式如下:

    <variable> = (<name>,<mode>)

    <name>:磁盘文件名;<mode> :打开模式;

    文件操作:

    文件读取:

    ​ read() 返回值为包含整个文件内容的一个字符串;

    ​ readline() 返回值为文件下一行内容的字符串;

    ​ Readlines() 返回值为整个文件内容的列表,每项是以换行符为结尾的一行字符串。

    例:将文件内容输出到屏幕上。

    1 def main():
    2     fname = eval(input("Enter filename:"))
    3     infile = open(fname,"r")
    4     data = infile.read()
    5     print(data)
    6 main()

    例:输出文件前五行内容。

    1 infile = open("mood.txt","r")
    2 for i in range(5):
    3     line = infile.readline()
    4     print(line[: -1])

    运行结果:

    happy
    joy
    nice
    wonderful
    pretty

    文件内容:

    写入文件:从计算机内存向文件写入数据。

    write():把含有本文数据或者二进制数据块的字符串写入文件中。

    writelines():针对列表操作,接受一个字符串列表作为参数,将它们写入文件。     例:

    >>> outfile = open("mood.txt","w")
    >>> outfile.writelines(["Hello"," ","world"])
    >>> outfile.close()
    >>> infile = open("mood.txt","r")
    >>> infile.read()
    'Hello world'

    文件遍历

    关闭文件:

    file.close()

    字典:

    字典是针对非序列集合而提供的一种数据类型;

    映射:通过任意键值查找集合中值信息的过程;

    字典是键值对的集合:

    ​ 该集合以键为索引;

    ​ 同一个键信息对应一个值;

    字典类型与序列类型的区别:
    • 存取和访问的方式不同
    • 键的类型不同:

    ​ 序列类型只能用数字类型的键;

    ​ 字典类型可以用其他对象类型作键;

    • 排列方式不同:

    ​ 序列保持了元素的相对关系;

    ​ 而字典中的数据是无序排列的

    • 映射方式不同:

    ​ 序列类型通过地址映射到值;

    ​ 字典类型通过键直接映射到值;

    字典的操作:

    为字典增加一项 : dictionaryName[key] = value

    访问字典中的值 :dictionaryName[key]返回键key对应的值value

    删除字典中的一项:del dictionaryName[key]

    字典的遍历:

    ​ 遍历字典的键key:

    for key in dictionaryName.keys():print.(key)

    ​ 遍历字典的值value:

    for value in dictionaryName.values():print.(value)

    ​ 遍历字典中的项:

    for item in dictionaryName.items():print.(item)

    ​ 遍历字典的key-value:

    for item,value in adict.items():print(item,value)

    是否一个键在字典中:in 或者 not in

    字典的标准操作符:-,<,>,<=,>=,==,!=,and,or,not

    “统计词频”问题解决步骤:

    ​ 输入英文文章;

    ​ 建立用于词频计算的空字典;

    ​ 对文本的每一行计算词频;

    ​ 从字典中获取数据对到列表中;

    ​ 对列表中的数据对交换位置,并从大到小进行排序

    ​ 输出结果

    ​ 最后用Turtle库绘制统计词频结果图表

    计算思维的本质:

    ​ 抽象、自动化

    ​ 实证思维、逻辑思维、计算思维

    ​ 随机算计科学发展而提出

    ​ 理解计算特性

    ​ 将计算特性抽象为计算问题

    ​ 程序设计实现问题的在自动求解

    自顶而下的设计过程总结:

    ​ 步骤1:将算法表达为一系列小问题;

    ​ 步骤2:为每个小问题涉及接口;

    ​ 步骤3:通过将算法表达为接口关联的多个小问题来细化算法;

    ​ 步骤4:为每个小问题重复上述过程。

    自底向上的执行

    体育竞技分析的例子(已知两个运动员单次比赛获得胜利的概率,求在规定的比赛次数中两人分别获得最终胜利的概率)

    
    
     1 from random import * 
     2  
     3 def main():
     4     printIntro()
     5     probA,probB,n = getInputs()
     6     winsA, winsB = simNGames(n,probA,probB)
     7     PrintSummary(winsA, winsB)
     8  
     9 def printIntro():
    10     print('This program simulates a game between two')
    11     print('There are two players, A and B')
    12     print('Probability(a number between 0 and 1)is used')
    13  
    14 def getInputs():
    15     a = eval(input('What is the prob.player A wins?'))
    16     b = eval(input('What is the prob.player B wins?'))
    17     n = eval(input('How many games to simulate?'))
    18     return a,b,n
    19  
    20 def simNGames(n,probA,probB):
    21     winsA = 0
    22     winsB = 0
    23     for i in range(n):
    24         scoreA,scoreB = simOneGame(probA,probB)
    25         if scoreA >scoreB:
    26             winsA = winsA + 1
    27         else:
    28             winsB = winsB + 1
    29     return winsA,winsB
    30 def simOneGame(probA,probB):
    31     scoreA = 0
    32     scoreB = 0
    33     serving = "A"
    34     while not gameOver(scoreA,scoreB):
    35         if serving == "A":
    36             if random() < probA:
    37                 scoreA = scoreA + 1
    38             else:
    39                 serving = "B"
    40         else:
    41             if random() < probB:
    42                 scoreB = scoreB + 1
    43             else:
    44                 serving = "A"
    45     return scoreA,scoreB
    46  
    47 def gameOver(a,b):
    48     return a==15 or b==15
    49  
    50 def PrintSummary(winsA, winsB):
    51     n = winsA + winsB
    52     print('
    Games simulated:%d'%n)
    53     print('Wins for A:{0}({1:0.1%})'.format(winsA,winsA/n))
    54     print('Wins for B:{0}({1:0.1%})'.format(winsB,winsB/n))
    55  
    56 if __name__ == '__main__':
    57     main()

    软件开发方法:

    软件工程

    软件开发生命周期:

    ​ 确定问题、可行性分析、系统分析、系统设计、编码、测试、安装维护

    软件开发模式:

    ​ 瀑布模式(重视各个阶段的顺序性)、螺旋模式(设计、执行并测试原型,再设计、执行并测试新特征,将原型逐步扩展为最终程序)、快速原型模式、喷泉模式、混合模式、敏捷开发模式

    原型的例子:

    import random
    def simOneGame():
        scoreA = 0
        scoreB = 0
        serving = "A"
        for i in range(30):    
            if serving == "A":
                if random.random() < 0.5:
                    scoreA = scoreA + 1
                else:
                    serving = "B"
            else:
                if random.random() < 0.5:
                    scoreB = scoreB + 1
                else:
                    serving = "A"
        print(scoreA)
        print(scoreB)
    simOneGame()

    ​ 阶段1:构建最初的原型;

    ​ 阶段2:添加两个参数代表两个球员赢球的概率;

    ​ 阶段3:进行比赛,直到一个球员达到15分;

    ​ 阶段4:将比赛扩展为多场比赛;

    ​ 阶段5:建立完整的程序;

    敏捷开发方法:

    ​ 以人为核心、迭代、循序渐进;

    ​ 针对传统的瀑布开发模式的弊端;

    ​ 分为多个相互联系,独立运行的小项目;

    ​ 软件一直处于可使用状态。

    敏捷开发典型过程:

    1. ​ 对产品形成共识;
    2. ​ 建立和维护产品需求列表,并进行优先级排序;
    3. ​ 筛选高优先级需求进入本轮迭代开发;
    4. ​ 细化本轮迭代需求,一次在本轮迭代完成;
    5. ​ 每日召开站立会议。(任务看板)
    6. ​ 对每轮迭代交付的可工作软件,进行现场验收和反馈;
    7. ​ 从第3步开始,进行下一轮迭代。

    面向过程的程序设计:

    ​ 以程序执行过程为设计流程的思想,结构化编程;

    例:输入铅球的初始角度、高度、速度和飞行时间,求铅球的飞行距离(为简化问题忽略空气阻力,重力加速度为9.8米每二次方秒)。

     1 from math import pi,sin,cos,radians
     2  
     3 def main():   
     4     angle = eval(input("Enter the launch angle (in degrees):"))
     5     vel = eval(input("Enter the initial velocity (in meters/sec):"))
     6     h0 = eval(input("Enter the initial height (in meters):"))
     7     time = eval(input("Enter the time interval: "))
     8  
     9     xpos = 0
    10     ypos = h0
    11  
    12     theta = radians(angle)      #将角度转换为弧度制
    13     xvel = vel * cos(theta)
    14     yvel = vel * sin(theta)     
    15  
    16     while ypos >= 0:
    17         xpos = xpos + time * xvel
    18         yvell = yvel - time * 9.8
    19         ypos = ypos + time * (yvel + yvell)/2.0
    20         yvel = yvell
    21     print("
    Distance traveled:{0:0.1f}meters.".format(xpos))
    22      
    23 if __name__ == "__main__":
    24     main()
    面向过程程序设计基本步骤:

    ​ 分析程序从输入到输出的各步骤;

    ​ 按照执行过程从前到后编写程序;

    ​ 将高耦合部分封装成模块或函数;

    ​ 输入参数,按照程序执行过程调试;

    面向对象的程序设计:

    类:某种类型集合的描述,包含属性和方法。

    类的定义:

    ​ class classname[(父类名)]:[成员函数及成员变量]

    ​ _init_构造函数:初始化对象的各属性;

    ​ _del_析构函数:销毁对象。

    面向对象实例(铅球飞行距离):

    定义类:

    
    
     1 from math import sin, cos, radians
     2  
     3 class Projectile:
     4     def __init__(self, angle, velocity, height):
     5         #根据给定的发射角度、初始速度和位置创建一个投射体对象
     6         self.xpos = 0.0
     7         self.ypos = height
     8         theta = radians(angle)
     9         self.xvel = velocity * cos(theta)
    10         self.yvel = velocity * sin(theta)
    11  
    12     def update(self, time):
    13         #更新投射体的状态
    14         self.xpos = self.xpos + time * self.xvel
    15         yvell = self.yvel - 9.8 * time
    16         self.ypos = self.ypos + time * (self.yvel + yvell) / 2.0
    17         self.yvel = yvell
    18  
    19     def getY(self):
    20         #返回投射体的角度
    21         return self.ypos
    22  
    23     def getX(self):
    24         #返回投射体的距离
    25         return self.xpos

    调用类模块的主函数:

     1 from Projectile import *
     2  
     3 def getInputs():
     4     a = eval(input("Enter the launch angle (in degrees):"))
     5     v = eval(input("Enter the initial velocity (in meters/sec):"))
     6     h = eval(input("Enter the initial height (in meters):"))
     7     t = eval(input("Enter the time interval: "))
     8     return a,v,h,t
     9  
    10 def main():
    11     angle,vel,h0,time = getInputs()
    12     shot = Projectile(angle,vel,h0)
    13     while shot.getY() >=0:
    14         shot.update(time)
    15     print("
    Distance traveled:{0:0.1f}meters.".format(shot.getX()))
    16    
    17 if __name__ == "__main__":
    18     main()
    面型对象的特点:

    ​ 封装、多态、继承

  • 相关阅读:
    Codeforces 1255B Fridge Lockers
    Codeforces 1255A Changing Volume
    Codeforces 1255A Changing Volume
    leetcode 112. 路径总和
    leetcode 129. 求根到叶子节点数字之和
    leetcode 404. 左叶子之和
    leetcode 104. 二叉树的最大深度
    leetcode 235. 二叉搜索树的最近公共祖先
    450. Delete Node in a BST
    树的c++实现--建立一棵树
  • 原文地址:https://www.cnblogs.com/ST-2017/p/8407505.html
Copyright © 2011-2022 走看看