总结

一.定义函数

1. 什么是函数

   1. 概念

      函数就是实现某一特定功能的代码的封装 -> 一个函数对应一个功能（函数存储的功能）

   2. 分类(按照函数由谁创建的进行分类)

      1. 系统函数 - 有Python语言已经创建好的函数(Python自带的函数)，例如：print、input、type、id、max、min、sorted、sum等
      2. 自定义函数 - 由程序员自己创建的函数

2. 定义函数

   1. 语法

      def 函数名(形参列表):
          函数说明文档
          函数体
      

   2. 说明

      def     -       关键字；固定写法
      函数名   -       由程序员自己命名；
                      要求：是标识符，不能是关键字
                      范围：见名知义(看到函数名就大概知道函数的功能是什么)、
                           不使用系统的函数名、类名、模块名、
                           字母都小写，多个单词用下划线隔开
      ():     -      固定写法
      形参列表    -  以'变量名1, 变量名2, 变量名3,...'的形式存在，这儿每一个变量就是一个形参；形参可以一个都没有，也可以有多个。
                    形参可以将函数外部的数据传递到函数内部；
                    定义函数的时候需不需要形参需要几个看实现函数的功能需不需要额外的数据，需要几个
      函数说明文档  -   本质就是和def保持一个缩进多行注释；用来对函数的功能、参数和返回值进行说明的 （说明书）
      函数体     -   和def保持一个缩进的一条或者多条语句，本质就是实现函数功能的代码。
      

   3. 练习

      # 练习1： 写一个函数求两个数的和
      def sum2(num1, num2):
          """
          (功能说明区)求任意两个数的和
          :param num1: (参数说明) 数字1
          :param num2: 数字1
          :return: (返回值说明) None
          """
          print(num1 + num2)
      
      sum2(10, 20)
      
      # 练习2：写一个函数求5乘以6的结果
      def product(num1, num2):
          print(num1 * num2)
      
      product(5, 6)
      product(99, 120)
      
      # 练习3： 写一个函数统计指定字符串中数字字符的个数
      def count_number(str1):
          """统计数字字符的个数"""
          count = 0
          for x in str1:
              if x.isdigit():
                  count += 1
          print(count)
      
      count_number('ajhf1238山海经02')
      count_number('数的2791')
      
      # 练习4：定义一个函数获取任意一个整数(正负都可以)的十位数
      def get_tens_digit(num):
          """获取十位数"""
          if num < 0:
              num *= -1
          print(num // 10 % 10)
      
      get_tens_digit(123)
      get_tens_digit(-132)
      
      # 练习5：定义一个函数，获取指定列表中所有数字元素
      def get_numbers(list1):
          """获取数字元素"""
          new_list = []
          for x in list1:
              if type(x) in (int, float):
                  new_list.append(x)
          print(new_list)
      
      get_numbers([19, '是d', 23.8, True, None])
      
      
      # 练习6：定义一个函数，获取两个字符串的公共部分
      def get_common_char(str1, str2):
          """获取两个字符串的公共部分"""
          result = set(str1) & set(str2)
          print(''.join(result))
      
      get_common_char('abcn', '123ba92')
      
      
      # 练习7：定义一个函数交换字典的键和值
      def change_key_value(dict1):
          new_dict = {}
          for key in dict1:
              new_dict[dict1[key]] = key
          print(new_dict)
      
      change_key_value({'a': 10, 'b': 20, 'c': 30})
      

二.调用函数

1. 调用函数

   1. 重要结论：定义函数的时候不会执行函数，调用的时候才会执行

   2. 语法:

      函数名(实参列表)

   3. 说明

      函数名     -     需要哪个函数的功能就调用哪个函数，想要调用哪个函数就写哪个函数的函数名
                      注意：这儿的函数名必须是已经定义过的函数的函数名
      ()        -     固定写法
      实参列表    -    以 '数据1, 数据2, 数据3,...' 的形式存在；实参就是真正通过形参传递到函数内部的数据
                      实参的个数由形参决定，默认情况被调用的函数有多少个形参调用的时候就需要多少个实参
      

   4. 函数调用过程

      当代码执行到函数调用语句的时候：
      第一步：回到函数定义的位置
      第二步：传参(用实参给形参赋值的过程)，传参的时候必须保证每个形参都有值
      第三步：执行函数体
      第四步：确定返回值  
      第五步：回到函数调用的位置，接着往后执行
      
            ```python
            def func1():
                # print('abc'[10])
                print('=====================')
                print('====hello python=====')
                print('=====================')
            
            
            func1()
            
            
            def sum2(num1, num2):
                """(功能说明区)求任意两个数的和"""
                # 传参：num1 = 10; num2 = 20
                print(num1 + num2)    # print(10 + 20)  -> print(30)
            
            
            sum2(10, 20)
            sum2(100, 200)
      

三.函数的参数

1. 位置参数和关键字参数 - 根据实参的传递方式不同将函数的实参分为这两种

   1. 位置参数

      调用函数的时候直接将多个数据用逗号隔开，实参和形参从位置上一一对应

   2. 关键字参数

      调用函数的时候，在数据前面加上’形参名=’，实参和形参由形参名来对应

   3. 两种参数混用

      要求必须保证位置参数在关键字参数的前面

      def func1(x, y, z):
          print(f'x:{x}, y:{y}, z:{z}')
      
      
      func1(10, 20, 30)
      func1(20, 10, 30)
      func1(x=100, y=200, z=300)
      func1(z=3, x=1, y=2)
      func1(10, y=20, z=30)
      func1(10, z=30, y=20)
      func1(10, 20, z=30)
      # func1(10, b=20, 30)   # 报错! SyntaxError: positional argument follows keyword argument
      

2. 参数默认值

   1. 定义函数的时候可以给形参赋默认值，调用函数的时候已经有默认的参数可以不用传参，直接使用默认值。

   2. 如果是给部分参数赋默认值，必须保证没有默认值的参数在有默认值参数的前面

      def func2(x=1, y=2, z=3):
          print(f'x:{x}, y:{y}, z:{z}')
      
      
      func2(10, 20, 30)
      func2()
      func2(100)
      func2(100, 200)
      func2(y=200)
      
      def func3(x, y, z=3, t=4):
          pass
      
      def connect(host, user, pw, port=3306):
          pass
      

3. 参数类型说明 - 定义函数的时候指定参数类型

   1. 没有默认值的参数添加类型说明

      形参名:数据类型

   2. 有默认值的参数，默认值的类型就是参数的类型

4. 不定长参数

   1. 带*的不定长参数

      1. 在形参前面加*，那么这个参数就变成了一个元组，用来接收对应的所有的实参（实参是元组中的元素）

      2. 记住：如果函数参数在带*的参数的后面，那么后面的这些参数在调用的时候必须使用关键字参数

         # 定义一个函数求多个数的和
         def sum1(*nums):
             print(nums)
         
         
         sum1(10, 20)
         sum1(2, 34, 5)
         sum1(10, 29, 38, 9, 19)
         sum1(1)
         sum1()
         
         
         def student_info(name, *score):
             print(name, score)
         
         student_info('小明')
         student_info('小花', 397, 420)
         student_info('张三', 397, 328, 300)
         

   四.函数的返回值

   1. 意义：返回值就是从函数内部传递到函数外部的数据

   2. 怎么确定返回值(怎么将函数内部的数据作为返回值传递到函数外部)：

      1. 在函数体中，将需要返回的数据放到return的后面;
      2. return后面的值是多少，函数的返回值就是多少，如果没有return，返回值None

   3. 怎么获取返回值(在函数外部怎么获取从函数内部传递出来的数据)：

      1. 在函数外部获取函数调用表达式的结果;
      2. 函数调用表达式的值就是函数的返回值

   4. 什么时候需要返回值：如果实现函数的功能产生了新的数据，将新的数据作为返回值返回

      def sum2(n1, n2):
          # n1 = 10; n2 = 20
          result = n1 + n2     # result = 30
          print(f'内部:{result}')
          return result      # return 30
      
      a = sum2(10, 20)      # 函数调用表达式的值就是函数的返回值
      print(f'a:{a}')
      
      
      def func1():
          return 100
      
      # b = 100
      b = func1()
      print(f'b:{b}')
      
      print(100 * 2, func1() * 2)
      
      print(100 < 200, func1() < 200)
      
      list1 = [100, 200, func1()]
      print(list1)
      
      def func2():
          return 'abc'
      
      print(func2())
      print('abc'[-1], func2()[-1])    # 'abc'[-1]
      
      def sum3(x, y):
          return x + y
      
      result = sum3(100, 230)
      print(result)
      

   作业

   1. 编写一个函数，交换指定字典的key和value。

      # 例如:dict1={'a':1, 'b':2, 'c':3}  -->  dict1={1:'a', 2:'b', 3:'c'}  
      def exchange_key_value(dict1:dict):
          """交换字典的键和值"""
          result = {value:key for key,value in dict1.items()}
          return result
      

   2. 编写一个函数，提取指定字符串中所有的字母，然后拼接在一起产生一个新的字符串

      #   例如: 传入'12a&bc12d-+'   -->  'abcd'  
      def get_letters(str1:str):
          """提取指定字符串中所有的字母"""
          str2 = ''
          for i in str1:
              if 'a' <= i <= 'z' or 'A' <= i <= 'Z':
                  str2 += i
          return str2
      

   3. 写一个自己的capitalize函数，能够将指定字符串的首字母变成大写字母

      #  例如: 'abc' -> 'Abc'   '12asd'  --> '12asd'
      def change_initial(str1:str):
          """将指定字符串的首字母变成大写字母"""
          str2 = ''
          first = str1[0]
          if 'a' <= first <= 'z':
              first = chr(ord(first) - 32)
              str2 = first + str1[1:]
              return str2
          else:
              return str1
      

   4. 写一个自己的endswith函数，判断一个字符串是否已指定的字符串结束

      #   例如: 字符串1:'abc231ab' 字符串2:'ab' 函数结果为: True
      #        字符串1:'abc231ab' 字符串2:'ab1' 函数结果为: False
      def new_endswith(str1:str, str2:str):
          """判断一个字符串是否已指定的字符串结束"""
          a = len(str2)
          result = (str1[-a:] == str2)
          return result
      

   5. 写一个自己的isdigit函数，判断一个字符串是否是纯数字字符串

      #   例如: '1234921'  结果: True
      #         '23函数'   结果: False
      #         'a2390'    结果: False
      def new_isdigit(str1:str):
          """判断一个字符串是否是纯数字字符串"""
          for i in str1:
              if not'0' <= i <= '9':
                  return False
                  break
          else:
              return True
      

   6. 写一个自己的upper函数，将一个字符串中所有的小写字母变成大写字母

      #    例如: 'abH23好rp1'   结果: 'ABH23好RP1'   
      def new_upper(str1:str):
          """将一个字符串中所有的小写字母变成大写字母"""
          str2 = ''
          for i in str1:
              if 'a' <= i <= 'z':
                  i = chr(ord(i) - 32)
              str2 += i
          return str2
      

   7. 写一个自己的rjust函数，创建一个字符串的长度是指定长度，原字符串在新字符串中右对齐，剩下的部分用指定的字符填充

      #   例如: 原字符:'abc'  宽度: 7  字符:'^'    结果: '^^^^abc'
      #       原字符:'你好吗'  宽度: 5  字符:'0'    结果: '00你好吗'
      def new_rjust(str1:str, width:int, char1:str):
          """用指定的字符填充"""
          a = len(str1)
          str2 = char1 * (width - a) + str1
          return str2
      

   8. 写一个自己的index函数，统计指定列表中指定元素的所有下标，如果列表中没有指定元素返回-1

      #  例如: 列表: [1, 2, 45, 'abc', 1, '你好', 1, 0]  元素: 1   结果: 0,4,6  
              列表: ['赵云', '郭嘉', '诸葛亮', '曹操', '赵云', '孙权']  元素: '赵云'   结果: 0,4
              列表: ['赵云', '郭嘉', '诸葛亮', '曹操', '赵云', '孙权']  元素: '关羽'   结果: #-1      
      def new_index(list1:list, element):
          """统计指定列表中指定元素的所有下标，如果列表中没有指定元素返回-1"""
          list2 = []
          if element in list1:
              for index,item in enumerate(list1):
                  if item == element:
                      list2.append(index)
              return list2
          else:
              return -1
      

   9. 写一个自己的len函数，统计指定序列中元素的个数

          例如: 序列:[1, 3, 5, 6]    结果: 4
               序列:(1, 34, 'a', 45, 'bbb')  结果: 5  
      #         序列:'hello w'    结果: 7
      def new_len(sequence):
          """统计指定序列中元素的个数"""
          count = 0
          for i in sequence:
              count += 1
          return count              
      

   10. 写一个自己的max函数，获取指定序列中元素的最大值。如果序列是字典，取字典值的最大值

         例如: 序列:[-7, -12, -1, -9]    结果: -1   
              序列:'abcdpzasdz'    结果: 'z'  
       #        序列:{'小明':90, '张三': 76, '路飞':30, '小花': 98}   结果: 98
       def max_value(sequence):
          """获取指定序列中元素的最大值"""
          if type(sequence) == list:
              sequence.sort(reverse=True)
              return sequence[0]
          elif type(sequence) == str:
              max_value = sequence[0]
              for i in range(1,len(sequence)):
                  if max_value < sequence[i]:
                      max_value = sequence[i]
              return max_value
          else:
              max_value = sequence['小明']
              for i in sequence:
                  if max_value < sequence[i]:
                      max_value = sequence[i]
              return max_value
       

   11. 写一个函数实现自己in操作，判断指定序列中，指定的元素是否存在

           例如: 序列: (12, 90, 'abc')   元素: '90'     结果: False
       #         序列: [12, 90, 'abc']   元素: 90     结果: True 
       def new_in(sequence, item):
           """判断指定序列中，指定的元素是否存在"""
           for i in sequence:
               if i == item:
                   return True
           else:
               return False
       

   12. 写一个自己的replace函数，将指定字符串中指定的旧字符串转换成指定的新字符串

       #    例如: 原字符串: 'how are you? and you?'   旧字符串: 'you'  新字符串:'me'  结果: #'how are me? and me?'
       def new_replace(str1:str, str2, str3):
           """将指定字符串中指定的旧字符串转换成指定的新字符串"""
           if str2 in str1:
               new_str = str3.join(str1.rsplit(str2))
               return new_str