JavaScript开发者学习Python: 1.2 函数

• 定义函数
  • 在 JavaScript 中 定义函数使用关键字 function

     function my_ads (x){
       if(x > 0 ){
          return x
       }else{
          return -x
       }
    

  • 在 Python 中 定义函数使用关键字 def

     def my_ads (x , y = 0 ) {  # 默认参数 同 JavaScript ES6中的默认参数
       if not isinstance(x, (int, float)):  # 规定必须为整数或者浮点数
          raise TypeError('bad operand type')  # 抛出异常
       if x > 0 :
          pass # 占位符 不能为空如果没想好怎么写,必须写个占位符来让代码继续执行下去
       else :
          return -x , y #  Python 中 允许返回多个值, 返回类型为 tuple 
                        #  a,b = (1,2)
                        #  print(a , b)  
                        #  1 2
                        #  在 Python 中 多个变量可以同时接收一个tuple，按位置赋给对应的值 , 这点同 JavaScript 中的 ES6 结构赋值类似
     } 
    

• Python 中 函数的参数 ( Python 中的 函数的参数与 JavaScript 区别交大,这里只介绍 Python的函数参数)
  • 可变参数 ( 允许你传入0个或任意个参数，这些可变参数在函数调用时自动组装为一个tuple )

    def carl (numbers) : 
        sum = 0
        for n in numbers :
            sum = sum + n * n
        return sum 
    carl([1,2,3]) # 传递一个list 返回为 14
    carl((1,2,3)) # 传递一个tuple 返回为 14
    

    • 我们把carl 稍加改动让 参数 numbers 变成一个可变参数 如下

      def carl (*numbers) : 
        sum = 0
        for n in numbers :
            sum = sum + n * n
        return sum 
      carl(1,2,3) # 14  参数前面加了一个*号。在函数内部，参数numbers接收到的是一个tuple，
      carl()      # 0 因此，函数代码完全不变。但是，调用该函数时，可以传入任意个参数
      

    • 同时我们在修改传入的参数 如下

      def carl (*numbers) : 
        sum = 0
        for n in numbers :
          sum = sum + n * n
        return sum 
      list = [1,2,3]
      tuple = (1,2,3)
      #------------------分割线------------------
      carl(list) # 报错
      carl(tuple) # 报错
      carl(*list) # 14
      carl(*tuple) # 14
      # 下面我们观察一下 list 与 tuple 加上关键字 * 
      print(*list) # 1 2 3
      print(list) # [1,2,3]
      print(*tuple) # 1 2 3
      print(tuple) # (1,2,3)
      

      • 由此我们得知 关键字 * 放在 变量 list 或 tuple 前, 实际是把所有元素作为可变参数传递进去
      • 因此我们函数 carl 又刚好接收的是可变参数,所以我们的必须吧 list 与 tuple 转换成可变参数传入函数中
  • 关键字参数 ( 允许你传入0个或任意个含参数名的参数，这些关键字参数在函数内部自动组装为一个dict )

    def person(name,age,**km) :
        print('name:',name,'age:',age,'other:',km)
    person('Michael' , 30) # name: Michael age: 30 other:{}
    person('Michael' , 30 , city='BeiJing' , job='Engineer') 
    # name: Michael age: 30 other:{ 'city':'BeiJing' , 'job':'Engineer'}
    

    • 我们在定义一个dict 来传递参数

      def person(name,age,**km) :
          print('name:',name,'age:',age,'other:',km)
       extr = {'city': 'Beijing', 'job': 'Engineer'}
       person('Jack',24,extr ) # 报错
       person('Jack',24, **extr ) 
       # name: Jack age: 24 other: {'city': 'Beijing', 'job': 'Engineer'}
      

      • **extr 表示吧 extr 这个dict的所有key-value用关机子传输传入函数的**km参数 这里个km活的是 dict 是extra的拷贝,对km的改动不会影响extr
      • 同可变参数中的关键字* 同理,只是关键字 * 拆分的是 list 与 tuple 而 **拆分的是 dict
  • 命名关键字参数 (限制关键字参数的名字)

    def person(name,age,*,city,job):
        print(name,age,city,job)
    person('LiLei',80,city='BeiJing',job='IT') 
    # LiLei 80 BeiJing IT
    

    • 和关键字参数**km 不同 , 命名关机子参数需要一个特殊分符号* , * 后面的参数被视为命名关机子参数
    • 如果函数定义中已经有了一个可变参数 , 后面跟着命名关键字参数就不在需要一个特殊分符号*了。如下

    def person (name ,age , *args , city='BeiJing' , job) :
        print(name,age,args,city,job)
    person ('LingDa' , 28, ('参数1', '参数2' , '参数3') , 'ShangHai' , 'IT')
    # 报错   命名关键字参数必须传入参数名，这和位置参数不同。如果没有传入参数名，调用将报错
    person ('LingDa' , 28, ('参数1', '参数2' , '参数3') , city='ShangHai' , job = 'IT')
    # LingDa 28 (('参数1', '参数2', '参数3'),) ShangHai IT
    person ('LingDa' , 28, ('参数1', '参数2' , '参数3')  , job = 'IT')
    # LingDa 28 (('参数1', '参数2', '参数3'),) BeiJing IT