python 函数的初识

01 内容大纲

1. 函数的初识
2. 函数的结构与调用
3. 函数的返回值
4. 函数的参数

02 具体内容

1. 函数的初识

   • 写一个获取字符串总个数的代码，不能用len():

     s1 = 'fjkdsfjdssudafurpojurojregreuptotuproq[t'
     count = 0
     for i in s1:
         count += 1
     print(count)
     

   • 写一个获取列表总个数的代码：

     l1 = [1, 2, 3, 4, 5, 6]
     count = 0
     for i in l1:
         count += 1
     print(count)
     
     

     这样的写代码的缺点：
     重复代码太多。
     代码的可读性差。

   • 利用函数写出上面的功能：

     #将上面的那些重复代码封装到函数中，这样，需要使用这个功能时通过一个指令调用即可。
     s1 = 'fsjkdafshdjfsdhafjksda'
     l1 = [1,2,3,4,5,6]
     
     def my_len(s):
         count = 0
         for i in s:
             count += 1
         print(count)
     my_len(s1)#22
     my_len(l1)#6
     

   • 函数：以功能（完成一件事）为导向，如：登录，注册，len就是一个函数。一个函数就是一个功能。 随调随用。

   • 函数的优点：

     • 减少代码的重复性。
     • 增强了代码的可读性。

2. 函数的结构与调用

   • 结构： def 关键字，定义函数。
     meet 函数名：与变量设置相同，要具有可描述性。
     函数体 ：缩进，函数体一定全部都要缩进，这代表是这个函数的代码。函数中尽量不要出现 print

     def 函数名():
     
         函数体

   • 函数的调用：函数什么时候执行？

     • 当函数遇到 ‘函数名()’ 函数才会执行！！！

       def meet():
           print('打开tantan')
           print('左滑一下')
           print('右滑一下')
           print('找美女')
           print('悄悄话....')
           print('约....走起...')
       meet()  #执行函数
       meet()  #执行函数
       meet()  #执行函数

3. 函数的返回值

   #  return: 在函数中遇到return直接结束函数，不在继续往下执行。
   def meet():
       print('打开tantan')
       print('左滑一下')
       return             #在函数中遇到return直接结束函数。
       print('右滑一下')
       print('找美女')
       print('悄悄话....')
       print('约....走起...')
   
   meet()  #开始执行
   #结果：
   #打开tantan
   #左滑一下
   print(meet())# None  返回值
   # 打开tantan
   # 左滑一下
   # None   #没有设置返回值，返回None
   

   #  return 将数据返回给函数的执行者（调用者），即 meet()。
   def meet():
       print('打开tantan')
       print('左滑一下')
       print('右滑一下')
       print('找美女')
       print('悄悄话....')
       print('约....走起...')
       return '妹子一枚'              #return 后面有单个值
   meet()
   # 打开tantan
   # 左滑一下
   # 右滑一下
   # 找美女
   # 悄悄话....
   # 约....走起..
   
   ret = meet()
   print(ret)
   print(meet()) # 妹子一枚    #返回单个值
   #结果：
   打开tantan
   左滑一下
   右滑一下
   找美女
   悄悄话....
   约....走起...
   妹子一枚     #  妹子一枚 是 返回值    
   
   
   #类比：
   s1 = 'jfdkslfjsda'
   ret = len(s1)
   print(ret)
   

   # return 返回多个元素 是以元组的形式返回给函数的执行者。
   def meet():
       print('打开tantan')
       print('左滑一下')
       print('右滑一下')
       print('找美女')
       print('悄悄话....')
       print('约....走起...')
       return '妹子', 123, [22, 33]  #return 后面有多个值
   ret= meet()
   print(ret,type(ret))   #以元组的形式返回多个元素  ('妹子', 123, [22, 33]) <class 'tuple'>
   #结果：
    打开tantan
    左滑一下
    右滑一下
    找美女
    悄悄话....
    约....走起...
    ('妹子', 123, [22, 33]) <class 'tuple'>   
   
   ret,ret1,ret2 = meet() #元组拆包
   print(ret,ret1,ret2)#妹子 123 [22, 33]
   #结果：
   打开tantan
   左滑一下
   右滑一下
   找美女
   悄悄话....
   约....走起...
   妹子 123 [22, 33]
   

   • 返回值的总结：
     • return在函数中，终止函数。
     • return 可以给函数的执行者返回值：
       • return 单个值 ---> 单个值
       • return 多个值 ---> 多个值以元组的形式返回

4. 函数的参数

• 函数的传参：把函数封装的这个功能盘活。函数的传参就是函数将实际参数交给形式参数的过程
  分两个角度：实参，形参。

#我们写的函数也可以将一些数据传到函数里面的，然后让里面的代码利用上这个数据产生我们想要的结果，再返回

def meet(sex):  #函数的定义 ;接收的参数：形式参数   写在函数声明的位置的变量叫形参
    print('打开tantan')
    print('进行筛选：性别：%s' %(sex))
    print('左滑一下')
    print('右滑一下')
    print('找美女')
    print('悄悄话....')
    print('约....走起...')

meet('男')  # 函数的执行者传的参数 ：实际参数    在函数调用的时候给函数传递的值叫实参
#结果：
    打开tantan
    进行筛选：性别：男
    左滑一下
    右滑一下
    找美女
    悄悄话....
    约....走起...

• 实参角度

  1.位置参数: 从左至右，必须一一对应。

    def meet(sex,age,skill):
        print('打开tantan')
        print('进行筛选：性别：%s,年龄：%s,%s' %(sex,age,skill))
        print('左滑一下')
        print('右滑一下')
        print('找美女')
        print('悄悄话....')
        print('约....走起...')
  
    meet('女',25,'python技术好的')
  #结果：
  打开tantan
  进行筛选：性别：女,年龄：25,python技术好的
  左滑一下
  右滑一下
  找美女
  悄悄话....
  约....走起...
  
  
  例：写一个函数，只接受两个int的参数，函数的功能是将较大的数返回。
  def compare(a,b):
      c = 0
      if a > b:
          return c
      else:
          return c
  print(compare(10,20))  #20
  print(compare(1000,1)) #1000
  compare(1000,20)
  
  三元运算符： 简单的if else
  a = 1000
  b = 2000
  if a > b:
      c = a
  else:
      c = b
  print(c)
  #简化：
  a = 1000
  b = 2000
  c = a if a > b else b
  
  def compare(a,b):
      c = a if a > b else b  ##当a>b就把a赋值给c,否则就把b赋值给c
      return c
  #简化：
  def compare(a,b):
      return a if a > b else b
  

  2. 关键字参数：一一对应   不需要记住每个参数的位置. 只要记住每个参数的名字就可以了
    *【注意:  关键字不加引号，如age，weight等】

  def meet(sex,age,skill,hight,weight,):
        print('打开tantan')
        print('进行筛选：性别：%s,年龄：%s,技术：%s,身高：%s,体重%s' %(sex,age,skill,hight,weight))
        print('左滑一下')
        print('右滑一下')
        print('找美女')
        print('悄悄话....')
        print('约....走起...')
  
  meet(age=25,weight=100,hight=174,skill='python技术好的',sex='女')  #一一对应，可以不按顺序
  #结果：
  打开tantan
  进行筛选：性别：女,年龄：25,技术：python技术好的,身高：174,体重100
  左滑一下
  右滑一下
  找美女
  悄悄话....
  约....走起...
  
  例：函数：传入两个字符串参数，将两个参数拼接完成后形成的结果返回。
  def func(a,b):
      return a + b
  print(func(b='太白',a='无敌'))

  3. 混合参数

  # 混合参数：在调用函数的时候即可以给出位置参数, 也可以指定关键字参数.
  # 所有的位置参数一定要在关键字参数的前面，并且位置参数要从左到右一一对应。 关键字参数一一对应
  #【易错】**混合参数，所有位置参数一定要在关键字参数的前面------>如果实参的第一个参数为关键字参数，则后面的参数必须全部是关键字参数，不能是位置参数。
  
  def meet(sex,age,skill,hight,weight,):
      print('打开tantan')
      print('进行筛选：性别：%s,年龄：%s,技术：%s,身高：%s,体重%s' %(sex,age,skill,hight,weight))
      print('左滑一下')
      print('右滑一下')
      print('找美女')
      print('悄悄话....')
      print('约....走起...')
      return '筛选结果：性别：%s,体重%s' %(sex,weight)
  print(meet('女',25,weight=100,hight=174,skill='python技术好的'))
  #结果：
  打开tantan
  进行筛选：性别：女,年龄：25,技术：python技术好的,身高：174,体重100
  左滑一下
  右滑一下
  找美女
  悄悄话....
  约....走起...
  筛选结果：性别：女,体重100   #返回值

• 形参角度：

  1. 位置参数：位置参数其实与实参角度的位置参数是一样的，就是按照位置从左至右，一一对应

     def meet(sex,age,skill):
         print('打开tantan')
         print('进行筛选：性别：%s,年龄：%s,%s' %(sex,age,skill))
         print('左滑一下')
         print('右滑一下')
         print('找美女')
         print('悄悄话....')
         print('约....走起...')
     meet('女',25,'python技术好的',)
     
     例：写函数，检查传入列表的长度，如果大于2，那么仅保留前两个长度的内容，并将新内容返回给调用者。
     def func(l):
         if len(l) > 2:
             return l[:2]
         else:
             return l
     
     print(func([1,2,3,4,5]))#[1,2]
     print(func([1,])) #[1]
     
     #
     def func(l):
         c = l[:2] if len(l) > 2 else l
         return c
     
     print(func([1,2,3,4,5])) #[1,2]
     print(func([1,])) #[1]
     #简化：
     def func(l):
         return l[:2]
     
     l1 = [1,]
     print(l1[:2])#[1]

  2. 默认参数

     默认值参数  在函数声明的时候, 就可以给出函数参数的默认值.  默认参数设置的意义：普遍经常使用的,默认值参数一般是这个参数使用率较高，才会设置默认值参数
     
     def meet(age,skill='python技术好的',sex='女',):   # skill='python技术好的'，sex='女' 默认值.
         print('打开tantan')
         print('进行筛选：性别：%s,年龄：%s,技能：%s' %(sex,age,skill))
         print('左滑一下')
         print('右滑一下')
         print('找美女')
         print('悄悄话....')
         print('约....走起...')
     
     meet(25)  #默认参数可以不写
     #结果：
     打开tantan
     进行筛选：性别：女,年龄：25,技能：python技术好的
     左滑一下
     右滑一下
     找美女
     悄悄话....
     约....走起...
     
     meet(25,'运维技术好的','男')  #默认参数可以修改
     #结果：
     打开tantan
     进行筛选：性别：男,年龄：25,技能：运维技术好的
     左滑一下
     右滑一下
     找美女
     悄悄话....
     约....走起...
     
     
     

03 总结

1. 函数：

2. 函数的作用：以功能为导向，减少代码重复，使代码可读性好。

3. 函数的结构，函数的执行。

4. 函数的返回值：return 1，终止函数给函数的调用者返回值。

5. 函数的参数：

   • 实参角度

     • 位置参数
     • 关键字参数
     • 混合参数

   • 形参角度

     • 位置参数

     • 默认参数