“Python函数的基本使用”的版本间的差异

来自CloudWiki
跳转至： 导航， 搜索
（→‎函数的调用）
 
（未显示同一用户的36个中间版本）
第1行： 第1行：
 +
==问题引出==
 +
我们之前调用的这些简介的代码，他们有一个共同的名字叫什么 ？
 +
 +
*函数              描述
 +
*abs(x)            x的绝对值
 +
*divmod(x,y) 
 +
*pow(x,y)          x的y次幂
 +
*round(x,n）      x四舍五入，保留n位小数
 +
*max(x1,x2,...,xn) x1,x2,x3,...xn的最大值
 +
*min(x1,x2,...,xn) x1,x2,x3,...xn的最小值 
 +
 +
 +
*abs(x): 求绝对值
 +
<nowiki>>>> x,y = 9,2
 +
>>> abs(x)
 +
9
 +
>>> abs(-x)
 +
9</nowiki>
 +
*divmod(x,y)：获得除法的商和余数
 +
<nowiki>>>> x,y = 9,2
 +
>>> divmod(x,y)
 +
(4, 1)</nowiki>
 +
 
==函数是什么==
 
==函数是什么==
 
函数是一段具有特定功能的、可重用的语句组，通过函数名来表示和调用。
 
函数是一段具有特定功能的、可重用的语句组，通过函数名来表示和调用。
第6行： 第29行：
 
*将可能需要反复执行的代码封装为函数，并在需要该功能的地方进行调用，不仅可以实现代码复用，更重要的是可以保证代码的一致性，只需要修改该函数代码则所有调用均受到影响。
 
*将可能需要反复执行的代码封装为函数，并在需要该功能的地方进行调用，不仅可以实现代码复用，更重要的是可以保证代码的一致性，只需要修改该函数代码则所有调用均受到影响。
 
*设计函数时，应注意提高模块的内聚性，同时降低模块之间的隐式耦合。
 
*设计函数时，应注意提高模块的内聚性，同时降低模块之间的隐式耦合。
−
*例1：生日歌
+
*例1：群发祝福
 
  <nowiki>def happy():
 
  <nowiki>def happy():
 
     print("Happy birthday to you!")
 
     print("Happy birthday to you!")
第17行： 第40行：
 
happyTo("Lily")</nowiki>
 
happyTo("Lily")</nowiki>
  
−
==函数的使用==
+
==函数的定义==
 
函数的使用包括两部分：'''函数的定义'''和'''函数的调用'''。 函数是一种功能抽象。
 
函数的使用包括两部分：'''函数的定义'''和'''函数的调用'''。 函数是一种功能抽象。
  
−
===函数的定义===
+
===语法===
−
函数名：可以是任何有效的Python标识符
 
  
−
参数列表：是调用该函数时传递给它的值，可以有零个、一个或多个，当传递多个参数时各参数由逗号分隔，当没有参数时也要保留圆括号。
+
函数定义语法：
−
 
 
−
函数体：是函数每次被调用时执行的代码，由一行或多行语句组成。
 
−
 
 
−
 
 
−
*函数定义语法：
 
 
  <nowiki>def <函数名>([参数列表]):
 
  <nowiki>def <函数名>([参数列表]):
 
     '''注释'''
 
     '''注释'''
 
     <函数体>
 
     <函数体>
 
     return <返回值列表></nowiki>
 
     return <返回值列表></nowiki>
 +
 +
*函数名：可以是任何有效的Python标识符
 +
 +
*参数列表：是调用该函数时传递给它的值，可以有零个、一个或多个，当传递多个参数时各参数由逗号分隔，当没有参数时也要保留圆括号。
 +
 +
*函数体：是函数每次被调用时执行的代码，由一行或多行语句组成。
 +
 
*[[文件:java2-4.png]]
 
*[[文件:java2-4.png]]
  
−
如果需要返回值，使用保留字return和返回值 列表。函数可以没有return语句，函数体结束 后会将控制权返回给调用者。
+
如果需要返回值，函数体中使用保留字return返回值。函数可以没有return语句，函数体结束 后会将控制权返回给调用者。
 +
 
 +
[[文件:python2022112201.png|600px]]
  
 +
例：汇率计算器
  
−
*例1：生日歌
+
  <nowiki>
−
  <nowiki>def happy():
+
def DolConvert(Num):
−
     print("Happy birthday to you!")
+
     Num =eval(Num);
−
def happyTo(name):   
+
    Dollar =Num /6;
−
     print("Happy birthday, dear {}!".format(name))
+
    return Dollar
 +
   
 +
if __name__ == '__main__':         
 +
    Num = input("请输入人民币值: ")
 +
    result = DolConvert(Num)
 +
     print("能兑换的美元为：",result)</nowiki>
 +
 
 +
===拓展：if __name__ == '__main__':的作用===
 +
if __name__ == 'main':是程序的入口。
 +
 
 +
一个python文件通常有两种使用方法，第一是作为脚本直接执行，第二是 import 到其他的 python 脚本中被调用（模块重用）执行。因此 if __name__ == 'main': 的作用就是控制这两种情况执行代码的过程，在 if __name__ == 'main': 下的代码只有在第一种情况下（即文件作为脚本直接执行）才会被执行，而 import 到其他脚本中是不会被执行的。
 +
 
 +
练习：编写函数，给定两个直角边a,b的长度，计算斜边的长度。
 +
 
 +
练习：编写函数，求三个数a,b,c之间的最大值，
 +
 
 +
==函数设计的原则==
 +
*设计函数时，应注意提高模块的内聚性，同时降低模块之间的隐式耦合。
 +
 
 +
==函数的参数==
 +
参数列表：是调用该函数时传递给它的值，可以有零个、一个或多个，当传递多个参数时各参数由逗号分隔，当没有参数时也要保留圆括号。
  
−
happy( )   
+
<p>注意：</p>
−
happyTo("Mike")
 
−
print()
 
−
happyTo("Lily")</nowiki>
 
−
<p>'''注意事项'''</p>
 
 
*函数形参不需要声明类型，也不需要指定函数返回值类型
 
*函数形参不需要声明类型，也不需要指定函数返回值类型
 
*即使该函数不需要接收任何参数，也必须保留一对空的圆括号
 
*即使该函数不需要接收任何参数，也必须保留一对空的圆括号
 
*括号后面的冒号必不可少
 
*括号后面的冒号必不可少
−
*函数体相对于def关键字必须保持一定的空格缩进
 
−
*Python允许嵌套定义函数
 
  
−
*设计函数时，应注意提高模块的内聚性，同时降低模块之间的隐式耦合。
+
<nowiki>def multiply(x,y = 10):
−
===函数的调用===
+
    return x*y
 +
 
 +
s = multiply(99,2)
 +
print(s)
 +
</nowiki>
 +
 
 +
 
 +
==函数体==
 +
函数体：是函数每次被调用时执行的代码，由一行或多行语句组成。
 +
 
 +
函数体相对于def关键字必须保持一定的空格缩进
 +
 
 +
Python允许嵌套定义函数
 +
 
 +
函数体中可能存在return语句。函数执行结束后，根据return保留字的指示决 定是否返回结果，如果返回结果，则结果将被放置到函数被调用的位置，函数使用完毕，程序继续运行。
 +
 
 +
 
 +
例：阶乘函数的调用
 +
 
 +
<nowiki>#1*2*3*....*n
 +
def jiecheng(Num):
 +
    s =1
 +
    for i in range(1,Num+1):
 +
        s *= i
 +
 
 +
    return s
 +
 
 +
#n*(n+1)*...*m
 +
def jiecheng2(n,m):
 +
    if n>m:
 +
        n,m =m,n
 +
       
 +
    s =1
 +
    for i in range(n,m+1):
 +
        s *= i
 +
 
 +
    return s
 +
</nowiki>
 +
 
 +
*编写并调用函数，计算1*2*3*...*n的阶乘
 +
 
 +
*编写并调用函数 ，计算 n*(n+1)*...*m的值，其中n<m
 +
 
 +
==函数的返回值==
 +
关于return语句：
 +
 
 +
*在Python中，定义函数时也不需要声明函数的返回值类型，而是使用return语句结束函数执行的同时返回任意类型的值，函数返回值类型与return语句返回表达式的类型一致。
 +
*return语句用来结束函数，不论return语句出现在函数的什么位置，一旦得到执行将直接结束函数的执行。
 +
 
 +
*更多关于return语句，可以参考：[[Python函数的返回值]]
 +
 
 +
===例：计算平方和===
 +
如下函数返回两个数的平方和，请补充横线处代码‪‬‪‬‪‬‪‬‪‬‮‬‫‬‭‬‪‬‪‬‪‬‪‬‪‬‮‬‫‬‫‬‪‬‪‬‪‬‪‬‪‬‮‬‭‬‫‬‪‬‪‬‪‬‪‬‪‬‮‬‭‬‪‬‪‬‪‬‪‬‪‬‪‬‮‬‪‬‭‬
 +
 
 +
<nowiki>def psum(___①___):
 +
  ___②___ a**2 + b**2
 +
 
 +
a=eval(input())
 +
b=eval(input())
 +
print(psum(a,b))​</nowiki>
 +
 
 +
<nowiki>#寻找10~100的第一个“倒序数"
 +
 
 +
def revert( ):
 +
    for i in range(10,100):
 +
        a = i //10
 +
        b = i %10
 +
        print(a,b)
 +
        if a==b :
 +
            return i
 +
 
 +
    print("没有倒序数")
 +
    return 0
 +
 
 +
s =  revert( )
 +
print("10,100之间的倒序数为:",s)</nowiki>
 +
 
 +
函数也可以没有return：
 +
 
 +
*练习：编写函数，求两个数的最大公约数
 +
 
 +
<nowiki>求最大公约数与最小公倍数的方法很多，一个比较直观的方法是采用逐个尝试法。
 +
求a,b的最大公约数d，那么设置m=min(a,b)，一定d<=m，即d比a,b中最小的一个还小，于是可以从序列m,m-1,m-2,...,2,1中去寻找能被a,b除尽的数d，找到的第一个d就是a与b的最大公约数，最坏的情况是d=1。
 +
 
 +
</nowiki>
 +
 
 +
*练习：编写函数，求两个数的最小公倍数
 +
 
 +
<nowiki>求最大公约数与最小公倍数的方法很多，一个比较直观的方法是采用逐个尝试法。
 +
求a,b的最小公倍数c，那么设置m=max(a,b)，一定d>=m，即d比a,b中最大的一个还大，于是可以从序列m,m+1,m+2,...,a*b中去寻找能被a,b除尽的数d，找到的第一个d就是a与b的最小公倍数，最坏的情况是c=a*b。
 +
 
 +
</nowiki>
 +
 
 +
==函数的调用==
 
通过函数名调用函数功能，对函数的各个参数赋予实际值，称为函数的调用。
 
通过函数名调用函数功能，对函数的各个参数赋予实际值，称为函数的调用。
  
第67行： 第201行：
 
  4.函数调用结束后给出返回值，程序回到调用前的暂停处，继续执行。
 
  4.函数调用结束后给出返回值，程序回到调用前的暂停处，继续执行。
  
−
*例1：生日歌；例2：汇率计算器
+
编写并调用函数 ，计算 n*(n+1)*...*m的值，其中n<m
 +
 
 +
<nowiki>
  
−
*'''问题解决'''：编写生成斐波那契数列的函数并调用。
+
def jiecheng3(n,m):
−
*[[文件:java2-4.png]]
+
    s1 =jiecheng(m)
−
*在定义函数时，开头部分的注释并不是必需的，但如果为函数的定义加上注释的话，可以为用户提供友好的提示。
+
    s2 =jiecheng(n-1)
−
*[[文件:p5-1.png|600px]]
+
    s =s1/s2
 +
    print(s)
  
−
===例2：汇率计算器===
+
if __name__ == '__main__':
−
<nowiki>def DolConvert(Num):
+
     #n = eval(input("请输入一个数:"))
−
     Num =eval(Num);
+
    jiecheng2(3,5)
−
    Dollar =Num /6;
+
    jiecheng3(3,5)</nowiki>
−
    return Dollar
 
−
   
 
−
           
 
−
Num = input("请输入人民币值: ")
 
−
result = DolConvert(Num)
 
−
print("能兑换的美元为：",result)</nowiki>
 
−
<p>'''关于return语句'''</p>
 
−
*在Python中，定义函数时也不需要声明函数的返回值类型，而是使用return语句结束函数执行的同时返回任意类型的值，函数返回值类型与return语句返回表达式的类型一致。
 
−
*不论return语句出现在函数的什么位置，一旦得到执行将直接结束函数的执行。
 
−
*如果函数没有return语句、有return语句但是没有执行到或者执行了不返回任何值的return语句，解释器都会认为该函数以return None结束，即返回空值。
 
  
−
===函数返回===
+
编写并调用函数 ，计算1+（1+2）+（1+2+3）+（1+2+3+4）+，，，+（1+2+3+，，，+n)的和
−
函数执行结束后，根据return保留字的指示决 定是否返回结果，如果返回结果，则结果将被放置到函数被调用的位置，函数使用完毕，程序继续运行。
 
  
−
==函数的高级用法(可选）==
+
  <nowiki>#计算1+（1+2）+（1+2+3）+（1+2+3+4）+，，，+（1+2+3+，，，+n)的和
−
===函数嵌套定义===
+
'''
−
*Python允许函数的嵌套定义，在函数内部可以再定义另外一个函数。
+
#计算1+2+3+，，，+n)的和
−
>>> def myMap(iterable, op, value):    #自定义函数
+
def sum(n):
−
    if op not in '+-*/':
+
     s = 0
−
        return 'Error operator'
+
    for i in range(1,n+1,1):
−
    def nested(item):                  #嵌套定义函数
+
        s +=i
−
        return eval(repr(item)+op+repr(value))
+
    return s
−
     return map(nested, iterable)        #使用在函数内部定义的函数
 
−
>>> list(myMap(range(5), '+', 5))      #调用外部函数，不需要关心其内部实现
 
−
[5, 6, 7, 8, 9]
 
−
>>> list(myMap(range(5), '-', 5))
 
−
[-5, -4, -3, -2, -1]
 
  
−
*注：python 的repr函数可以参考 http://www.runoob.com/python/python-func-repr.html
+
def sum_total(n):
−
*问题解决：用函数嵌套定义和递归实现帕斯卡公式C(n,i) = C(n-1, i) + C(n-1, i-1)，进行组合数C(n,i)的快速求解。
+
     mysum =0
−
*[[文件:p5-2.png]]
+
     for i in range(1,n+1,1):
−
<nowiki>def f2(n,i):
+
         mysum += sum(i)
−
     cache2 = dict()
+
       
−
      
+
     return mysum</nowiki>
−
    def f(n,i):
 
−
        if n==i or i==0:
 
−
            return 1
 
−
        elif (n,i) not in cache2:
 
−
            cache2[(n,i)] = f(n-1, i) + f(n-1, i-1)
 
−
         return cache2[(n,i)]
 
−
   
 
−
     return f(n,i)</nowiki>
 
  
−
*使用标准库提供的缓冲机制进行改写和优化。
+
*例1：生日歌；例2：汇率计算器
−
<nowiki>from functools import lru_cache
 
  
−
@lru_cache(maxsize=64)
+
*'''问题解决'''：编写生成斐波那契数列的函数并调用。
−
def cni(n, i):
+
*[[文件:java2-4.png]]
−
    if n==i or i==0:
+
*在定义函数时，开头部分的注释并不是必需的，但如果为函数的定义加上注释的话，可以为用户提供友好的提示。
−
        return 1
 
−
    return cni(n-1, i) + cni(n-1, i-1)</nowiki>
 
−
===可调用对象===
 
−
*函数属于Python可调用对象之一，由于构造方法的存在，类也是可调用的。像list()、tuple()、dict()、set()这样的工厂函数实际上都是调用了类的构造方法。另外，任何包含__call__()方法的类的对象也是可调用的。
 
  
−
*下面的代码使用函数的嵌套定义实现了可调用对象的定义：
 
  
−
<nowiki>def linear(a, b):
 
−
    def result(x):              #在Python中，函数是可以嵌套定义的
 
−
        return a * x + b
 
−
    return result              #返回可被调用的函数</nowiki>
 
  
−
*下面的代码演示了可调用对象类的定义：
+
练习：设计一个由美元兑换人民币的函数
  
−
<nowiki>class linear:
+
思考：在求和的函数中，如何使求和的步长值也变为可自定义的？
−
    def __init__(self, a, b):
 
−
        self.a, self.b = a, b
 
−
    def __call__(self, x):        #这里是关键
 
−
        return self.a * x + self.b</nowiki>
 
  
−
*使用上面的嵌套函数和类这两种方式中任何一个，都可以通过以下的方式来定义一个可调用对象：
+
==练习==
−
taxes = linear(0.3, 2)
+
编写并调用函数，计算1*2*3*...*n的阶乘
−
*然后通过下面的方式来调用该对象：
 
−
taxes(5)
 
−
===修饰器===
 
−
*修饰器（decorator）是函数嵌套定义的另一个重要应用。修饰器本质上也是一个函数，只不过这个函数接收其他函数作为参数并对其进行一定的改造之后使用新函数替换原来的函数。
 
−
*Python面向对象程序设计中的静态方法、类方法、属性等也都是通过修饰器实现的。
 
−
<nowiki>def before(func):                      #定义修饰器
 
−
    def wrapper(*args, **kwargs):
 
−
        print('Before function called.')
 
−
        return func(*args, **kwargs)
 
−
    return wrapper
 
  
−
def after(func):                        #定义修饰器
+
编写并调用函数 ，计算 n*(n+1)*...*m的值，其中n<m
−
    def wrapper(*args, **kwargs):
 
−
        result = func(*args, **kwargs)
 
−
        print('After function called.')
 
−
        return result
 
−
    return wrapper
 
  
−
@before
+
思考：在求和的函数中，如何使求和的步长值也变为可自定义的？
−
@after
 
−
def test():                            #同时使用两个修饰器改造函数
 
−
    print(3)
 
−
#调用被修饰的函数
 
−
test()</nowiki>
 
  
−
返回 [[Python函数和代码复用]]
+
编写函数，求三个数a,b,c之间的最大值，

2023年5月23日 (二) 04:12的最新版本

问题引出

我们之前调用的这些简介的代码，他们有一个共同的名字叫什么 ？

  • 函数 描述
  • abs(x) x的绝对值
  • divmod(x,y)
  • pow(x,y) x的y次幂
  • round(x,n） x四舍五入，保留n位小数
  • max(x1,x2,...,xn) x1,x2,x3,...xn的最大值
  • min(x1,x2,...,xn) x1,x2,x3,...xn的最小值


  • abs(x): 求绝对值
>>> x,y = 9,2
>>> abs(x)
9
>>> abs(-x)
9
  • divmod(x,y)：获得除法的商和余数
>>> x,y = 9,2
 >>> divmod(x,y)
(4, 1)

函数是什么

函数是一段具有特定功能的、可重用的语句组，通过函数名来表示和调用。

经过定义，一组语句等价于一个函数，在需要使用这组语句的地方，直接调用函数名称即可。

  • 将可能需要反复执行的代码封装为函数，并在需要该功能的地方进行调用，不仅可以实现代码复用，更重要的是可以保证代码的一致性，只需要修改该函数代码则所有调用均受到影响。
  • 设计函数时，应注意提高模块的内聚性，同时降低模块之间的隐式耦合。
  • 例1：群发祝福
def happy():
    print("Happy birthday to you!")
def happyTo(name):    
    print("Happy birthday, dear {}!".format(name))

happy( )    
happyTo("Mike")
print()
happyTo("Lily")

函数的定义

函数的使用包括两部分：函数的定义和函数的调用。 函数是一种功能抽象。

语法

函数定义语法： 

def <函数名>([参数列表]):
    '''注释'''
    <函数体>
    return <返回值列表>
  • 函数名：可以是任何有效的Python标识符
  • 参数列表：是调用该函数时传递给它的值，可以有零个、一个或多个，当传递多个参数时各参数由逗号分隔，当没有参数时也要保留圆括号。
  • 函数体：是函数每次被调用时执行的代码，由一行或多行语句组成。
  • Java2-4.png

如果需要返回值，函数体中使用保留字return返回值。函数可以没有return语句，函数体结束 后会将控制权返回给调用者。

Python2022112201.png

例：汇率计算器 

def DolConvert(Num):
    Num =eval(Num);
    Dollar =Num /6;
    return Dollar
    
if __name__ == '__main__':           
    Num = input("请输入人民币值: ")
    result = DolConvert(Num)
    print("能兑换的美元为：",result)

拓展：if __name__ == '__main__':的作用

if __name__ == 'main':是程序的入口。

一个python文件通常有两种使用方法，第一是作为脚本直接执行，第二是 import 到其他的 python 脚本中被调用（模块重用）执行。因此 if __name__ == 'main': 的作用就是控制这两种情况执行代码的过程，在 if __name__ == 'main': 下的代码只有在第一种情况下（即文件作为脚本直接执行）才会被执行，而 import 到其他脚本中是不会被执行的。

练习：编写函数，给定两个直角边a,b的长度，计算斜边的长度。

练习：编写函数，求三个数a,b,c之间的最大值，

函数设计的原则

  • 设计函数时，应注意提高模块的内聚性，同时降低模块之间的隐式耦合。

函数的参数

参数列表：是调用该函数时传递给它的值，可以有零个、一个或多个，当传递多个参数时各参数由逗号分隔，当没有参数时也要保留圆括号。

注意：

  • 函数形参不需要声明类型，也不需要指定函数返回值类型
  • 即使该函数不需要接收任何参数，也必须保留一对空的圆括号
  • 括号后面的冒号必不可少
def multiply(x,y = 10):
    return x*y

s = multiply(99,2)
print(s)


函数体

函数体：是函数每次被调用时执行的代码，由一行或多行语句组成。

函数体相对于def关键字必须保持一定的空格缩进

Python允许嵌套定义函数

函数体中可能存在return语句。函数执行结束后，根据return保留字的指示决 定是否返回结果，如果返回结果，则结果将被放置到函数被调用的位置，函数使用完毕，程序继续运行。


例：阶乘函数的调用 

#1*2*3*....*n
def jiecheng(Num):
    s =1
    for i in range(1,Num+1):
        s *= i

    return s

#n*(n+1)*...*m 
def jiecheng2(n,m):
    if n>m:
        n,m =m,n
        
    s =1
    for i in range(n,m+1):
        s *= i

    return s
  • 编写并调用函数，计算1*2*3*...*n的阶乘
  • 编写并调用函数 ，计算 n*(n+1)*...*m的值，其中n<m

函数的返回值

关于return语句：

  • 在Python中，定义函数时也不需要声明函数的返回值类型，而是使用return语句结束函数执行的同时返回任意类型的值，函数返回值类型与return语句返回表达式的类型一致。
  • return语句用来结束函数，不论return语句出现在函数的什么位置，一旦得到执行将直接结束函数的执行。

例：计算平方和

如下函数返回两个数的平方和，请补充横线处代码‪‬‪‬‪‬‪‬‪‬‮‬‫‬‭‬‪‬‪‬‪‬‪‬‪‬‮‬‫‬‫‬‪‬‪‬‪‬‪‬‪‬‮‬‭‬‫‬‪‬‪‬‪‬‪‬‪‬‮‬‭‬‪‬‪‬‪‬‪‬‪‬‪‬‮‬‪‬‭‬ 

def psum(___①___):
   ___②___ a**2 + b**2

a=eval(input())
b=eval(input())
print(psum(a,b))​

#寻找10~100的第一个“倒序数"

def revert( ):
    for i in range(10,100):
        a = i //10
        b = i %10
        print(a,b)
        if a==b :
            return i

    print("没有倒序数")
    return 0

s =  revert( )
print("10,100之间的倒序数为:",s)

函数也可以没有return：

  • 练习：编写函数，求两个数的最大公约数
求最大公约数与最小公倍数的方法很多，一个比较直观的方法是采用逐个尝试法。
求a,b的最大公约数d，那么设置m=min(a,b)，一定d<=m，即d比a,b中最小的一个还小，于是可以从序列m,m-1,m-2,...,2,1中去寻找能被a,b除尽的数d，找到的第一个d就是a与b的最大公约数，最坏的情况是d=1。
  • 练习：编写函数，求两个数的最小公倍数
求最大公约数与最小公倍数的方法很多，一个比较直观的方法是采用逐个尝试法。
求a,b的最小公倍数c，那么设置m=max(a,b)，一定d>=m，即d比a,b中最大的一个还大，于是可以从序列m,m+1,m+2,...,a*b中去寻找能被a,b除尽的数d，找到的第一个d就是a与b的最小公倍数，最坏的情况是c=a*b。

函数的调用

通过函数名调用函数功能，对函数的各个参数赋予实际值，称为函数的调用。

实际值可以是实际数据，也可以是在调用函数前已经定义过的变量。

  • 程序调用一个函数需要执行以下四个步骤。
1.调用程序，在调用处暂停执行。
2.在调用时将实参复制给函数的形参。
3.执行函数体语句。
4.函数调用结束后给出返回值，程序回到调用前的暂停处，继续执行。

编写并调用函数 ，计算 n*(n+1)*...*m的值，其中n<m 


def jiecheng3(n,m):
    s1 =jiecheng(m)
    s2 =jiecheng(n-1)
    s =s1/s2
    print(s)

if __name__ == '__main__':
    #n = eval(input("请输入一个数:"))
    jiecheng2(3,5)
    jiecheng3(3,5)

编写并调用函数 ，计算1+（1+2）+（1+2+3）+（1+2+3+4）+，，，+（1+2+3+，，，+n)的和 

 #计算1+（1+2）+（1+2+3）+（1+2+3+4）+，，，+（1+2+3+，，，+n)的和
'''
#计算1+2+3+，，，+n)的和
def sum(n):
    s = 0
    for i in range(1,n+1,1):
        s +=i
    return s

def sum_total(n):
    mysum =0
    for i in range(1,n+1,1):
        mysum += sum(i)
        
    return mysum
  • 例1：生日歌；例2：汇率计算器
  • 问题解决：编写生成斐波那契数列的函数并调用。
  • Java2-4.png
  • 在定义函数时，开头部分的注释并不是必需的，但如果为函数的定义加上注释的话，可以为用户提供友好的提示。


练习：设计一个由美元兑换人民币的函数

思考：在求和的函数中，如何使求和的步长值也变为可自定义的？

练习

编写并调用函数，计算1*2*3*...*n的阶乘

编写并调用函数 ，计算 n*(n+1)*...*m的值，其中n<m

思考：在求和的函数中，如何使求和的步长值也变为可自定义的？

编写函数，求三个数a,b,c之间的最大值，

取自“http://www.openbrains.net/mediawiki/index.php?title=Python函数的基本使用&oldid=33188”