Python-函数

1. 函数也叫方法，比如你用手机打电话就是一个函数，你只管用就好，里面的功能别人已经帮你研发好了，你只需要输入手机号，按下拨打电话就好了，这个概念用在代码里尤为重要，比如重复某个功能，比如用户输入，你要判断用户输入，你要判断用户的输入不能为空，那么这个你可以定义一个函数，就是用来判断用户的输入是否为空，每次调用一下就可以，假如现在校验用户输入的需求变化了，那么你直接维护这个函数就好了，没必要再去所有的代码里找这个校验，一个个的去改，所有函数有以下两个显而易见的优点：
   1. 重复代码精简，简化复用性代码的编写，将重复性代码写成函数，要用的时候调用即可；
   2. 方便以后维护，你改一个函数，所有调用这个函数的地方的功能都能及时更新，避免修改代码遗漏
2. 函数在前面的字符串方法已经接触过了，像strip()这些，就是python内置的一些函数，当然还有很多，这些函数python已经帮我们写好了，直接用就好了，这样是不是很方便，什么时候需要什么时候就调用。显而易见，函数要调用的时候才会执行，调用函数就是在函数名后加（）就可以调用了，像strip()这些。
3. 函数初识
   1. 定义函数的时候，写的入参叫形参；
   2. 调用函数的时候，传的值叫实参；

   3. 1 def sayName(name,age,sex):  #name,age,sex就是形式参数
      2     # name,age,sex函数的参数类型是位置参数、必填参数
      3     print('姓名：%s'%name)
      4     print('年龄：%s'%age)
      5     print('性别：%s'%sex)
      6     #上面这个就是函数体
      7 
      8 
      9 sayName('星星',18,'男')  #'星星',18,'男'这三个就是实际参数，调用的时候传进来的参数
      

      　　

4. 函数ruturn
   1. 函数如果需要返回值，用return即可，有两点需要注意：
      • 函数里，只要遇到return就结束，不会再往下运行
      • 如果函数没有指定return返回值，那么函数默认返回的是None

      •  1 def call(a,b):
         2     return a+b
         3     return a*b
         4 def call2(a,b):
         5     print('函数内a,b运行结果：',a+b)
         6 
         7 print('call函数return结果：',call(1,2))
         8 print('call2函数return结果：',call2(1,2))
         9 
        10 #call函数return结果： 3    #因为函数里return了a+b的结果，所以这里的结果是3
        11 #函数内a,b运行结果： 3     #这个是call2函数体里运行的结果
        12 #call2函数return结果： None    #因为函数里没有return，所以这里的结果是None
        

        　　

5. 函数即变量
   1. 之前接触过变量，在内存里开放一个地方存变量，函数也是一样的，也是变量，存在内存里的某个地方，调用直接就是函数名（），就调用了，看一个有趣的调用方法，先定义一个字典，value存函数名，根据key来调用相应的函数

      1.  1 def play():
          2     print('出去浪')
          3 def study():
          4     print('好好学习')
          5 def_method={'1':play,'2':study}
          6 while True:
          7     choice = input('请输入你的选择：1代表出去浪，2代表好好学习')
          8     if choice =='1' or choice =='2':
          9         def_method[choice]()
         10         print(type(def_method[choice]()))
         11         break
         12     else:
         13         print('请输入正确的选择')
         14         continue
         

         　　

      2. while True：是死循环，这里只是写一个循环，真实的工作场景中，需要填写正确的条件判断
         　　

6. 入参类型
   1. 函数的入参有很多类型，上面已经了解过位置参数，还有默认参数，可变参数，关键字参数
   2. 注意参数有顺序，如果上述四种参数你都有用，那么参数类型顺序必须是：位置参数 -> 默认参数 -> 可变参数 -> 关键字参数，否则报错
      • 位置参数：这个参数就和格式化输出里的占位一样，形参先把位置站好，然后就等着用户调用的时候输入实参，排队填坑，如果实参和形参个数不一致，多了或者少了都会报错，如下：

        • 1 def add(a,b):
          2     print('%s+%s=%s'%(a,b,a+b))
          3     return a*b
          4 add(1,2)    #打印结果：1+2=3
          5 add(6,2)    #打印结果：6+2=8
          6 add(1,2,3)  #打印结果：报错，参数多了
          7 add(2)      #打印结果：报错，参数少了
          

          　　

      默认参数：
      这个参数就是程序会先给一个默认的，不传不会报错，会直接使用默认的这个参数值，如果传了就用你传的这个值；等于是定义函数的时候先定义了一个参数变量，调用的时候没传就用之前定义好的，如果传了就是覆盖之前的值，用传入的参数值：

      • 1 def multi(a,b=2):
        2     print('%s**%s=%s'%(a,b,a**b))
        3 
        4 multi(3)   #不传参的时候默认b=2，这里求的是平方
        5 multi(4,3) #传的时候b=3，这里求的是立方
        6 multi(2,b=4) #和上面的这个调用是一样的，但是一般这样写，如果默认参数较多时，不会因为位置而出错
        7 multi(b=4,2) #报错，位置参数必须在前（positional argument follows keyword argument）
        

        　　

      • 可变参数：这里一般用的少，可变就是参数是变化的，考虑到了程序的扩展性，定义函数的时候并不确定会有多少个参数，这里就用到了可变参数，既然可变，那么在调用函数的时候也是可以不输入的：

        •  1 # 可变参数
           2 def user(name,passwd,*args):   #一般是用args来命名的，当然也可以用其他你想要的名字
           3     print('用户名：%s,密码：%s'%(name,passwd))
           4     print('还有如下属性：
          ',args)   #这里的args，就是用户输入参数的一个元祖
           5 
           6 user('chenmeng',12334,'男','180cm','60kg')
           7 # 打印结果：
           8 # 用户名：chenmeng,密码：12334
           9 # 还有如下属性：
          10 # ('男', '180cm', '60kg')
          

          　　

          　　
      • 关键字参数，也不是必填的，他是一个key-value的字典形式：

        • 1 # 关键字参数:也不是必填的，他是一个key-value的字典形式
          2 def user(name,passwd,**args):
          3     print('用户名：%s，密码：%s'%(name,passwd))
          4     print('还有如下属性：
          ',args)
          5 user('xingxing',123456,sex='男',height='180cm')
          6 # 打印结果：
          7 # 用户名：xingxing，密码：123456
          8 # 还有如下属性：
          9 # {'sex': '男', 'height': '180cm'}
          

          　　

7. 变量作用域
   1. 变量作用域有四种：全局作用域，局部作用域，内建作用域，闭包函数外的函数中，后两者用的少，全局作用域和局部作用域概念用的多。全局作用域就是变量在所有的范围都可以用，比如在代码开始定义一个变量，那么不论是在函数外部还是内部都可以用这个变量；局部作用域就是只能在某个区域内才能用，除了这个区域就用不了了，比如函数内定义的变量只能在函数体内用，出了函数就用不了 了。（建议不要使用全局变量，不安全，所有人都可以修改）
   2. 全局作用域

      • 1 # 全局作用域
        2 hys=['屏幕','主机'] #全局变量
        3 def add(thing):
        4     hys.append(thing)
        5 add('麦克')
        6 print(hys)  #打印结果为：['屏幕', '主机', '麦克'

   3. 局部作用域

      1 # 局部作用域
      2 def add(thing):
      3     desk=['显示器','鼠标']  #局部变量
      4     desk.append(thing)     #函体内修改局部变量      
      5 add(223)
      6 print(desk)                #函数体外调用局部变量报错
      

      　　

      • 值得一提的是，当全局变量是一个不可编辑的参数时，需要先申明才可以用全局变量（str/int/float等不可变变量函数在调用全局变量时，需要global才可以修改）

      •  1 # 不可变变量的全局变量引用，如int、float、str
         2 money = 500
         3 def chage():
         4     money=1000
         5     print('函数内的money：',money)   #打印结果是1000，因为函数内部作用域中money=1000，不能修改外面的money
         6 chage()
         7 print('函数外的money：',money)   #打印结果为500，因为函数不可修改外部作用域中不可变变量的全局变量引用，如int、float、str
         8 
         9 def chage():
        10     global money    #global后就可以引用了，这就声明了money是一个全局变量，函数内可以修改
        11     money =1000
        12     print('函数内的money：',money)   #打印结果是1000
        13 chage()
        14 print('函数外的money：',money)     #打印结果是1000,因为global声明了全局变量，所以可以修改
        

        　　

   4. 1. 函数迭代，就是自己调用自己，一个死循环，一直调用下去，最多迭代999次，超过999次程序自动停止运行（while没有次数限制）
   5. 啊
8. 函数迭代
   1. 函数迭代，就是自己调用自己，一个死循环，一直调用下去，最多跌倒999次，超过999次程序自动停止运行（while没有次数限制）。既然这样，那么迭代肯定要有一些特性才可以正常调用：
      1. 必须有一个明确的结束条件
      2. 每次进入更深一层递归时，问题规模相比上次递归都因有所减少
      3. 递归效率不高，递归层次过多会导致栈溢出（在计算机中，函数调用是通过栈（stack）这种数据结构实现的，每当进入一个函数调用，栈就会加一层栈帧，每当函数返回，栈就会减一层栈帧。由于栈的大小不是无限的，所以，递归调用的次数过多，会导致栈溢出）

      4. 1 # 函数迭代，就是自己调用自己，一个死循环，调用下去
         2 def dd():
         3     print('学习学习努力学习')
         4     dd()    #函数内，又调用了函数本身，那么就会一直调用下去
         5 dd()   #迭代函数最多会调用999次，这里会打印999次'学习学习努力学习'
         

         　　

      5. 用函数迭代写斐波拉契数列：[1, 1, 2, 3, 5, 8, 13, 21, 34],数列从第3项开始，每一项都等于前两项之和。
      6. 先用之前的知识来写

         1.  1 list=[]
             2 def fb(num):
             3     a=1
             4     b=1
             5     while num >0:
             6         list.append(a)
             7         a,b=b,a+b
             8         print(b)
             9         num-=1
            10 fb(9)
            11 print(list)
            

            　　

      7. 用迭代来写

         1.  1 list=[]
             2 a=1
             3 b=1
             4 def fb(num):
             5     global a,b
             6     list.append(a)
             7     a,b=b,a+b
             8     num-=1
             9     if num>0:
            10         fb(num)
            11 
            12 fb(9)
            13 print(list)