Python日志9

函数学习总结

一、认识函数

• 1.什么是函数

  • a.函数就是实现某一特定功能的代码的封装 ，一个函数对应一个功能（函数存储的功能）
  • b.分类（按照函数由谁创建的进行分类）
    • 系统函数：由Python语言已经创建好的函数，列如:print,input,type,id,max,min,sorted,sum…
    • 自定义函数 —— 由程序员自己创建的函数

• 2.定义函数

  • 语法：

    def 函数名（形参列表）：

    ​ 函数说明文档

    ​ 函数体

  • 说明：

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

    def sum2(num1, num2):
        """
        (功能说明区)求任意两个数的和
        :param num1: (参数说明) 数字1
        :param num2: 数字1
        :return: (返回值说明) None
        """
        print(num1 + num2)
    
    
    sum2(10, 20)        #30
    

二.调用函数

• 调用函数（定义函数的时候不会执行函数，调用的时候才会执行函数）：

  • 语法：函数名（实参列表）
  • 说明：
    • 函数名 —— 需要哪个函数的功能就调用哪个函数，想要调用哪个函数就写哪个函数的函数名（这里的函数名必须是已经定义过的函数）
    • （） —— 固定写法
    • **实参列表 **—— 以’数据1，数据2，数据3，…'的形式存在；真正通过形参传递到函数内部的数据，实参的个数由形参决定，默认被调用的函数有多少个形参被调用就需要多少个实参
  • 调用函数的过程：
    • 第一步：回到函数定义的位置
    • 第二步：传参（用实参给形参赋值的过程），传参的时候必须保证每个形参都有值
    • 第三步：执行函数体
    • 第四部：确定返回值
    • 第五步：回到函数调用的位置，接着往下执行

  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)        #30
  sum2(100, 200)      #300
  
  

三、函数的参数

• 1.位置参数和关键参数 —— 根据实参的传递方式的不同将函数的实参分类

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

  • **b.关键字参数 **— 调用函数的时候，在数据前面加上’形参名=’，实参和形参由形参名对应

  • c…混合使用 — 必须保证位置参数在关键字参数前面

    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.参数默认值：

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

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

    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)
    

• 3.参数类型说明：

  • 定义函数的时候指定参数类型
  • 没有默认值的参数添加类型说明：形参名：数据类型
  • 有默认值的参数，默认值的类型就是参数的类型

• 4.不定长参数

  • 带 * 的不定长参数 — 在形参前面加*，那么这个参数就变成了一个元组，用来接收对应的所有的实参（实参是元组中的远元素）

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

  # 定义一个函数求多个数的和
  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.什么是返回值

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

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

    • 在函数体中，将需要返回的数据放到return的后面

    • return后面的值是多少，函数的返回值就是多少，如果没有return，返回值None

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

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

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

    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 change(dict1):
       new_dict = {}
       for x in dict1:
           new_dict[dict1[x]] = x
       print(new_dict)
   
   
   change({'a': 1, 'b': 2, 'c': 3})
   

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

      例如: 传入'12a&bc12d-+'   -->  'abcd'  
   

   def change(str1):
       new_str = ''
       for x in str1:
           if x.isalpha():
               new_str += x
       print(new_str)
   
   
   change('12a&bc12d-+')
   

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

     例如: 'abc' -> 'Abc'   '12asd'  --> '12asd'
   

   def change(str1):
       if 'a' <= str1[0] <= 'z':
           print(chr(ord(str1[0])-32) + str1[1:])
       else:
           print(str1)
   
   
   change('abc')
   

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

      例如: 字符串1:'abc231ab' 字符串2:'ab' 函数结果为: True
           字符串1:'abc231ab' 字符串2:'ab1' 函数结果为: False
   

   def estimate_end(str1, str2):
       if str1[-len(str2):] == str2:
           return True
       else:
           return False
   
   
   print(estimate_end('abc231ab', 'ab'))
   

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

      例如: '1234921'  结果: True         '23函数'   结果: False         'a2390'    结果: False
   

   def estimate_num(str1):
       for x in str1:        
           if not '0' <= x <= '9':            
               return False    
           else:        
               return True
           
           
   print(estimate_num('123'))
   

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

       例如: 'abH23好rp1'   结果: 'ABH23好RP1'   
   

   def upper_str(str1):
       new_str = ''    
       for x in str1:        
           if 97 <= ord(x) <= 122:            
               x = chr(ord(x) - 32)        
               new_str += x    
               
               
   print(new_str)upper_str('abH23好rp1')
   

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

      例如: 原字符:'abc'  宽度: 7  字符:'^'    结果: '^^^^abc'        原字符:'你好吗'  宽度: 5  字符:'0'    结果: '00你好吗'
   

   def align_right(str1, length: int, char: str):
       str2 = ''    
       str2 += (length-len(str1))*char + str1    
   
       
   print(str2)align_right('你好吗', 5, '0')
   

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

      例如: 列表: [1, 2, 45, 'abc', 1, '你好', 1, 0]  元素: 1   结果: 0,4,6          列表: ['赵云', '郭嘉', '诸葛亮', '曹操', '赵云', '孙权']  元素: '赵云'   结果: 0,4        列表: ['赵云', '郭嘉', '诸葛亮', '曹操', '赵云', '孙权']  元素: '关羽'   结果: -1         
   

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

       例如: 序列:[1, 3, 5, 6]    结果: 4         序列:(1, 34, 'a', 45, 'bbb')  结果: 5           序列:'hello w'    结果: 7
   

   def count_num(element):
       count = 0    
       for x in element:        
           count += 1    
   
   
   print(count)count_num('hello w')
   

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

      例如: 序列:[-7, -12, -1, -9]    结果: -1           序列:'abcdpzasdz'    结果: 'z'          序列:{'小明':90, '张三': 76, '路飞':30, '小花': 98}   结果: 98
    

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

        例如: 序列: (12, 90, 'abc')   元素: '90'     结果: False         序列: [12, 90, 'abc']   元素: 90     结果: True     
    

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

        例如: 原字符串: 'how are you? and you?'   旧字符串: 'you'  新字符串:'me'  结果: 'how are me? and me?'