Python之函数定义与参数

一.函数：将重复执行的代码定义成函数，可以通过函数名重复调用
         减少代码的重复性，提高代码的重用性
   1.定义:(函数名不能是关键字)
     1.1 def func(): # 函数基础框架
             print("first function")
     1.2 def func(): # 带返回值的函数
             print("first function with return value")
             value = 1   
             return value
     1.3 def func(args): # 带一个参数带返回值的函数
             print("the function has a {0}".format(args))
             value = 1
             return value
     1.4 def func(*args,**kwargs): # 任意个数参数带返回值的函数
             ...
             return vlaue
   2.函数返回值的种类:
     2.1 没有返回值--默认返回None，与只写一个return或者return None的情况是一样的，return可用作结束函数
         例如循环查找某对象，在循环未结束之前已经找到，则可用return结束函数，与break的
         结束循环不同，结束循环是指循环中break后的代码不再执行，结束函数，是函数内return
         后的所有代码均不执行，return可以返回任意数据类型，任意个数值，若返回多个值，以元组的形式返回
         返回值可以用多个变量接收，也可以用一个变量接收
            def func1():
                return 'a','b','c'
            res = func1();
            res1,res2,res3 = func1()
            print(res,res1,res2,res3) ==> ('a', 'b', 'c') a b c
            注：关于多个值接收,python中互换两个变量的值有最简单的写法
                a = 1
                b = 2
                a,b = b,a
                print(a,b) ==> 2 1
   3.函数参数：
     3.1 形参：
         写在函数定义时的参数称作“形参” -- def 函数名(形参)
          
     3.2 实参：
         函数调用时传入的参数称为“实参” -- 函数名(实参)
     3.3 没有参数 -- 定义时括号内不写任何内容
         一个参数 -- 定义时括号内写一个形参(定义一个变量),参数可以时基础数据类型，也可以时复杂数据结构
            def func(name)：
                print(name)
            func('张三')
            nameLst = ['张三','李四','王五','陆六']
            func(nameLst)
         多个参数：
            关于实参：
              按位置传参：
                 def func(name,age,job):
                     print("{0},{1},{2}".format(name,age,job))
                 func('张三','18','厨师')
              按关键字传参：
                 func(job='厨师',age='18',name='张三')
              同时包含位置和关键字传参:先按位置传参，再按关键字传参
                 func(job='厨师','张三','18')  ==> SyntaxError: positional argument follows keyword argument
                 func('李四','25',job='和尚')
         关于形参:
            通用参数：def func(name,age,job):
            默认参数: 定义时位置参数在前,默认参数要放最后
               def func(name,age,job='剑客'):
                   print("{0},{1},{2}".format(name,age,job))
               func('张三','18')
               
            动态参数:
               动态位置参数:(传入的参数组成一个元组)
                  def func(*args):
                      for i in args:
                          print(args,i)
                  func(1,2,3,4,5,6)
               注：先定义位置参数,*args,默认参数
               
               动态关键字传参:(传入的参数组成一个字典)
                   def func(**kwargs):
                       for i in kwargs:
                           print(kwargs,i,kwargs[i])
                   func(name='张三',age=18,job='厨师')
                   
               任意参数：
                   def func(*args,**kwargs):
                       print(args,kwargs)     
                   func(1,2,3,4,name='张三',age=18,job='厨师')
               位置参数任意参数关键字与默认参数传参组合:
                   def func(a1,a2,*args,d1='默认值1',d2='默认值二',**kwargs):
                       print(a1,a2,args,kwargs,d1,d2,kwargs)
                   func('位置1','位置2','任意1','任意2',kw1='关键字1',kw2='关键字2')
               *args与**kwargs的另一种传参方式
                   def func(*args,**kwargs):
                      print(args,kwargs)
                   lst = [x for x in range(10)]
                   dic = {'name':'张三','age'18,'job':'厨师'}
                   func(*lst,**dic) ==> (0, 1, 2, 3, 4, 5, 6, 7, 8, 9) {'name': '张三', 'age': 18, 'job': '厨师'}
               默认参数陷阱:(默认参数传入的是可变数据类型)
                   def func(num,lst=[]):
                       lst.append(num)
                       print(lst)
                   func(1) ==> [1]
                   func(2) ==> [1,2]
                   func(3) ==> [1,2,3]
                   func(1,[]) ==> [1]
                   func(2,[]) ==> [2]
                   func(3,[]) ==> [3]
                   定义默认参数如果是可变数据类型，此数据类型在定义的时候(赋值操作/初始化)就已经开辟出了内存空间
                   所有的调用共享同一块内存