python笔记--自定义函数

4591566

　　函数
　　函数是把一些负载的代码封装起来，需要的时候直接调用，重复利用提高效率并且能够简化程序的结构。
　　1.语法
　　定义一个函数要使用def语句，依次写出函数名、括号、括号中的参数、冒号:，然后，在缩进块中编写函数体，函数的返回值用return语句返回。
def functionName(parms1, parms2, ...):　　
    code block
　　
    return expression
　　2.函数的定义与调用
　　#定义函数
>>> def func1():　　
        print "aaa"
　　
        return "bbb"
　　注意：在Python交互环境中定义函数时，函数定义结束后需要按两次回车重新回到>>>提示符下。
　　#调用函数
>>> a=func1()　　
aaa
　　
>>> print a
　　
bbb
　　return作用：结束该语句块，并返回一个值。如果没有return语句或return后面为空，函数执行完毕后也会返回结果，只是结果为None。
　　在linux环境下，我们把函数（如func()）定义到一个.py文件中了（如test.py），那么，可以在该文件的当前目录下启动Python解释器，用from test import func来导入func()函数，注意test是文件名（不含.py扩展名）。
　　3.空函数
　　如果想定义一个什么事也不做的空函数，可以用pass语句：
>>>def func2():　　
       pass
　　pass语句什么都不做，那有什么用？
　　实际上pass可以用来作为占位符，比如现在还没想好怎么写函数的代码，就可以先放一个pass，让代码能运行起来。pass还可以用在其他语句里，比如：
if age >= 18:　　
    pass
　　缺少了pass，代码运行就会有语法错误。
　　4.函数参数
>>> def func3(name,age):    #括号中的叫形参　　
        print (name,age)
　　
        return (name,age)
　　

　　
>>> a=func3('fjc',25)        #括号中的叫实参
　　
        ('fjc', 25)
　　#参数检测
　　一般情况一个形参只能对应一个实参，在调用函数时，如果参数个数不对，Python解释器会自动检查出来，并抛出TypeError错误。
　　但是有两种形参可以对应多个实参，即可变参数和关键字参数，例如：
>>> def func4(*name):    #可变参数，有一个*　　
        print(name)
　　

　　
>>> a=func4('zhangsan','lisi')
　　
('zhangsan', 'lisi')     #输出结果为一个元组
　　

　　

　　
>>> def func5(**dic):    #关键字参数，有两个*
　　
        print(dic)
　　
>>> a=func5(zhangsan=12,lisi=15)    #注意实参的格式
　　
{'lisi': 15, 'zhangsan': 12}        #输出结果为一个字典
　　注意：可变参数和关键字参数同时出现时，可变参数在前，例如：
>>> def func6(*aa,**bb):　　
        print aa
　　
        print bb
　　

　　
>>> func6(1,2,3,a=1,b=2,c=3)
　　
(1, 2, 3)
　　
{'a': 1, 'c': 3, 'b': 2
　　如果，需要将已经定义的列表或元组、字典使用函数调用，需要在列表或元组前加一个*，在字典前加两个*，例如：
>>> lis=[1,2,3]　　
>>> dic={'a':1,'b':2}
　　
>>> a=[1,2,3]
　　
>>> b={'a':1,'b':2,'c':3}
　　
>>> def func7(*lis,**dic):
　　
        print (lis,dic)
　　

　　
>>> func7(*a,**b)    #a前加一个*，b前加两个*
　　
((1, 2, 3), {'a': 1, 'c': 3, 'b': 2})
　　#默认参数
>>> def func8(name,age=18):    #注意：默认参数只能放在形参的最后一个　　
        print (name,age)
　　
>>> func8('zhangsan')
　　
('zhangsan', 18)
　　#在调用函数时，实参不按顺序写，例如：
>>> func8(age=25,name='fjc')    #使用“形参=实参”的方式　　
('fjc', 25)
　　5.递归函数
　　在函数内部，可以调用其他函数。如果一个函数在内部调用自身本身，这个函数就是递归函数。例如：
　　#计算阶乘
>>> def func9(n):　　
        if n==1:
　　
        return n
　　
    return n*func9(n-1)
　　

　　
>>> func9(4)
　　
24
　　验算的过程如下：
　　4*func9(3)==>
　　4*3*func9(2)==>
　　4*3*2*func9(1)==>
　　4*3*2*1
　　递归函数的优点是定义简单，逻辑清晰。理论上，所有的递归函数都可以写成循环的方式，但循环的逻辑不如递归清晰。
　　练习：
　　1. 斐波那契数列（Fibonacci sequence），又称黄金分割数列，指的是这样一个数列：0、1、1、2、3、5、8、13、21、34、……。
　　随便输入两个数，生成类似的斐波那契数列。
#!/usr/bin/env python　　
def func (*number):
　　
    lis=[first,second]
　　
    for i in range(10):
　　
        lis1=list(reversed(lis))
　　
        lest=lis1[0]+lis1[1]
　　
        lis.append(lest)
　　
    print(lis)
　　
first=input("please input the first number:")
　　
second=input("please input the second number:")
　　
a=func(first,second)
　　#这个简单程序能够实现：在交互式模式随便输入两个数字，以这两个数字为基，输出斐波那契数列。
　　3. 输出 9*9 乘法口诀表
#!/usr/bin/env python　　
def func(n,m):
　　
    for x in range(1,10):
　　
        for y in range(1,x+1):
　　
            print "%d*%d=%d\t"%(x,y,x*y),
　　
        print ""
　　
func(1,10)
　　或者：
#!/usr/bin/env python　　
def func(n,m):
　　
    for x in range(n,m):
　　
        for y in range(n,m):
　　
            if x>=y:    #设为x<=y，是另一种效果
　　
                print"%d*%d=%d\t"%(x,y,x*y),
　　
            else:
　　
                continue
　　
        print ""
　　
a=func(1,10)
　　5. 有四个数字：1、2、3、4，能组成多少个互不相同且无重复数字的三位数？各是多少？
#!/usr/bin/env python　　
def func(a,b,c,d):
　　
    f=0
　　
    for x in (a,b,c,d):
　　
        for y in (a,b,c,d):
　　
            for z in (a,b,c,d):
　　
                if x!=y and x!=z and z!=y:
　　
                    print "%d%d%d"%(x,y,z)
　　
                    f+=1
　　
    print "total:%d"%f
　　
func(1,2,3,4)
　　6. 求s=a+aa+aaa+aaaa+aa...a的值，其中a是一个数字。例如2+22+222+2222+22222(此时共有5个数相加)，几个数相加由键盘控制。
#!/usr/bin/env python　　
def func(n,m):
　　
    x=[]
　　
    for i in range (1,m+1):
　　
         x.append(int("%d"%n*i))
　　
    print sum(x)
　　
n=input("number:")
　　
m=input("total:")
　　
func(n,m)