python函数（一）

      #函数基本应用，函数可以看做是语句的集合，通过函数调用来执行其包含的语句。函数可以返回一个计算结果，根据每次函数调用的参数
      #可以返回不同的计算结果，根据每次调用的参数，可以返回不同的计算结果。
      #python利用函数提高代码的重用率，减少了代码冗余。
      #定义函数
      #python使用def语句定义函数，基本格式如下：
      # def 函数名（参数表):
      # 函数语句
      # return 返回值
      #其中，参数和返回值都不是必须有的，python允许函数可以没有参数，也没有返回值。例如：
      def hello():
         print("python 你好")
      #调用函数；
      hello()
      #hello（）函数没有参数，也没有返回值，通过print（）打印一个字符串。下面的例子定义两个参数，并用return语句返回两个参数的和;
      #定义函数
      def add(a,b):
         return a+b
      #调用函数，并接受返回值;
      res=add(2,4)
      #打印输出的结果 ；
      print(res)
      #函数调用
      #在python中，所有的语句都是实时执行的，不像cc++存在编译过程。def也是一条可执行的语句，定义一个函数。所以函数的调用
      #必须在函数定义之后。
      #在python中，函数名也是一个变量，它引用return语句返回的值，没有返回值，函数值为None。
      #定义函数
      def mul(a,b):
         return a*b
      #直接访问函数名，可返回函数名的内存地址
      print(add)
      #如下是调用函数，并接受返回值，以及将函数名赋值给变量，然后使用变量进行调用。
      def div(a,b):
         return a/b
      #调用函数，并返回函数值；
      res=div(10,2)
      #打印结果；
      print("10/2=",res)
      #将函数名赋值给变量
      x=div
      #通过变量名来调用函数
      res=x(1,8)
      #打印结果;
      print(res)
      #函数参数，在定义函数的时候，参数中的各个参数成为形式参数，简称形参。调用函数时，参数表中提供的参数称为实际参数。
      #在python中，变量保存的是对象的引用，类似C C++中的指针。实际传递给形参的就是将对象的引用赋值给形参。
      #多态是，面向对象的一个特点，指同一个行为针对不同对象会得到不同的结果。python中的变量无类型属性，变量可引用各种不同
      #类型的对象。同一个函数，传递的实际参数不同时，可获得不同的结果，提现了多态。
      #支持“+”运算的对象均可作为参数
      def add(a,b):
         return a+b
      res=add(1,2.5)
      print("数值相加：",res)
      res=add("abc","def")
      print("字符串相加:",res)
      res=add((1,2),(3,8))
      print("元祖合并，",res)
      res=add([1,2],[3,4])
      print("列表合并：",res)
      #这里的+属于直接使用的方式，实现了多态。
      #参数赋值传递，通常函数调用时按参数的先后顺序，将实际传递形参传递给形参。例如调用add(1,2.5)时，1传递给a
      #2.5传递给b。python允许以形参赋值的方式，指定将实参传递给形参。
      #定义函数
      def add(a,b):
         return a+b
      #通过赋值来传递参数
      res=add(a='ab',b='cd')
      print(res)
      #通过赋值来传递参数；
      res=add(b='ab',a='cd')
      print(res)
      #可以看出来，在采用参数赋值传递时，因为指明了接受实参的形参名称，所以参数的先后顺序已经无关紧要。参数赋值传递方式
      #成了关键字传递。
      #3.参数传递与共享引用
      #定义函数
      def  f(x):
          x=100
      #定义变量，并将变量作为参数传入函数；
      a=10
      f(a)
      #执行后显示变量的值；
      print(a)
      #从结果可以看出，实际参数的值已经覆盖了原来的值100.
      #4.小心使用可变参数，当参数是可变参对象时，如列表、字典等，若在函数中修改形参，因为是共享引用
      #通过实参也获得修改后的对象。
      def  f(a):
         #修改列表第一个值
          a[1]='abc'
      #定义列表对象；
      x=[1,2]
      #调用函数，传递列表对象的引用
      f(x)
      #变量x引用的列表对象在函数中被修改。
      print(x)
      #可见，可变参数可在函数中被修改，如果不希望在函数中的修改影响函数外的变量，应该注意避免可变参数被修改。
      #如果要避免列表在函数中被修改，可使用列表的拷贝作为实参。例如：
      def f(a):
         #修改列表中的第一个值；
          a[0]='abc'
      x=[1,2]
      #传递列表的拷贝
      # f(x[:])
      print(x)
      #如果不希望在函数中的修改影响函数外的变量，应避免可变参数被修改。如果要避免列表在函数中被修改，可使用列表的拷贝
      #作为实际参数。
      def f(a):
         #拷贝列表；
          a=a[:]
         #修改列表的拷贝;
          a[0]='abc'
      x=[15,2]
      #调用函数
      f(x)
      #结果显示原列表不变
      print(x)
      #5.有默认值的参数；
      #在定义函数时，可以为参数设置一个默认值，调用函数时，如果未提供实际参数，则形参取默认值。例如：
      #定义函数;
      def add(a=9,b=-100):
         return a+b
      #传递指定参数；
      res=add(1,2)
      print(res)
      #形参b取默认值；
      res=add(1)
      print(res)
      res=add()
      print(res)
  
 

文章来源: aaaedu.blog.csdn.net，作者：tea_year，版权归原作者所有，如需转载，请联系作者。

原文链接：aaaedu.blog.csdn.net/article/details/81778400