python--005-函数参数变量

Posted 2020-10-30

·函数的参数
··参数
1、形式参数：parameter--形式参数
创建函数时，小括号内的参数
2、实际参数：argument--实参
函数调用时，小括号内传递进去的参数

··函数文档
1、直接书写字符串
2、用#标记单行的注释
3、可以用print（‘内容’）直接输出内容

#-- coding: utf-8 --
#这个函数求两个数值之和
def add(num1,num2):
‘把num1和num2 的和进行返回‘#这行字符串是一个注释
print (‘求两个值的和‘)
return num1+num2

print add(1,2)

函数文档的读取：
1、函数名.doc 两个下划线 属性名 doc里面存储文本与注释
int.doc
2.help(函数名)
help(str)

··关键字参数

定义了关键字的参数

1、位置参数：
直接给参数（和位置有关--一一对应）
2、关键字参数

    def myFunction(num1,num2):
    print num1,num2

    myFunction(num2=‘world‘,num1=‘hello‘)

    1、位置参数与关键字参数混用的时候，位置参数必须在关键字
            参数的前面
            def myFunction(a,b,c):
            print a,b,c
            myFunction(a=‘hello‘,‘world‘,‘python‘)

            返回错误

        2、不要给同一个形参多次赋值

          def myFunction(a,b,c):
          print a,b,c
          myFunction(a=‘hello‘,b=‘world‘,b=‘python‘)

            返回错误

···默认参数

是定义了默认值的参数

 def myFunction(a=‘hello‘,b=‘world‘):
 print a,b
 myFunction(‘hhe‘,‘dsb‘)

    返回hehe das

1、默认参数与位置参数混用的时候，位置参数必须在默认参数之前，位置参数要前面放
    def myFunction(a=‘hello‘,b=‘world‘):
    print a,b
    myFunction(,‘dsb‘)

            返回错误 
    2、默认参数只能在函数定义阶段赋值一次（仅仅一次）

      def myFunction(a=‘hello‘,b=‘world‘):
       print a,b
       myFunction()

        关键字参数在函数调用时候定义，默认参数在函数定义的时候赋值。

····可变长参数（收集参数）

1、在参数前面加上*
将所有参数打包元祖，进行输出

                    def fun(*a):
                    print a
                    fun(‘hehe‘,‘hello‘)

2、在参数上面加**
将所有参数打包成字典

·······命名关键字参数

可变长参数后面的参数应该使用命名关键字参数

    def fun(*a,b):
    print a
    fun(‘hehe‘,‘hello‘,b=‘world‘)

    def fun(b,*a):
    print a
    fun(‘hehe‘,‘hello‘,‘world‘)

1、可变长参数必须在位置参数后

print函数的参数就是可变长参数，输出元祖

API文档如何查看 help 或者F1

函数和过程

函数 function
过程 procedure

python 只有函数 ，没有过程

····返回值

即便没有在函数中写return语句，函数也会返回一个结果，这个结果为None，为空数据类型。

如果要返回多个值，可以直接书写，多个值之间用逗号隔开，返回值为一个元祖。

···函数变量的作用域

变量有作用域（变量的可见性）

1、局部变量：local variable

        1、定义在函数内部的变量
        2、先赋值，后使用
        3、作用范围从定义开始到包含代码块结束

2、全局变量 global variable

        1、定义在函数的外部
        2、先赋值后使用
        3、作用范围：整个文件，可以被多个函数调用
        4、如果局部变量与全局变量发生冲突，以局部变量为准

            def fun1(para1):
            print para1
            def fun2(para1):
            print para1
            a=10
            def fun3(para1):
                        a=20
                        print para1

            fun1(a)
            fun2(a)
            fun3(a)

在函数内部访问全局变量的时候，在函数内部创建一个相同的局部变量，原来局部变量不变
a=10
def fun3():
a=20
print a
fun3()
print a

3、global 全局变量

  a=10
        def fun3():
                        global a
                        a=20
                        print a
        fun3()
        print a

        结果返回两个20

        定义全局变量（如果在函数中修改global定义的变量，全局变量跟着改变）

·内嵌函数
定义在函数内部的函数：内嵌函数（内部函数）

内部函数的整个作用域，都在外部函数之内（从定义开始到包含它的代码块结束）

    1、外部函数的局部变量与内部函数的局部变量发生命名冲突，以内部函数的局部变量优先
    2.外部函数不能访问内部函数的局部变量
    3.在内部函数中访问外部函数的局部变量时，不能进行a+=1,这样的操作，原因就是a+1中的局部变量a没有赋值。

#lambda表达式
python 允许使用lambda表达式创建匿名函数

···匿名函数
没有函数名的函数：
lambda表达式：
1、关键字：lambda
2、创建形式：lambda函数的参数：函数的实现
3、lambda语句构建了一个函数对象，返回一个函数对象的信息，只需要赋值

  fun=lambda a:a+1
      print fun(3)

4、如果传入多个参数

    fun=lambda a,b,c:a+b+c
    print fun(2,3,4,)

··作用 
1、只需要使用一次，更加精简，不要单独创建函数
2、简化代码，提高代码的可读性

函数的嵌套与递归

··函数的嵌套：在一个函数中调用其他函数

解一元二次方程

                ax^2+bx+c=0

                x=frac{-b\pm{\sqrt{b^2-4ac}}}{2a}

    def jieFangCheng(a,b,c):
#先判断方程有没有解
            if qiuJie(a,b,c):#判断qiuJie()返回的真还是假
    #继续解方程求出所有的解
                delta = b*b-4*a*c
                x1=(-b+delta**0.5)/2*a
                x2=(-b-delta**0.5)/2*a
                print x1,x2

        else:
                print ‘无解‘
     def qiuJie(a,b,c):
            delta=b*b-4*a*c
            if delta>=0:
                    return True
            else:
                    return False
        jieFangCheng(1,1,1)

        jieFangCheng(1,1,-1)

··递归

递归：自己调用自己

        def factorial(n):
                    if n==1:
                                return 1
                    return n*factorial(n-1)
            print(factorial(4))

注意：防止无穷递归 与循环不同
汉诺塔

    def han(a,b,c,n):
                if n==1:
                        print a+‘---‘+b
                else:
                        han(a,c,b,(n-1))
                        print a+‘----‘+b
                        han(c,b,a,(n-1))
    han(‘A‘,‘B‘,‘C‘,3)