Day 11 Python 进阶 之 函数基础

Day 11 Python 进阶 之 函数基础

技巧总结

• 字符串方法中,用join()对序列中字符串字符进行连接时,特别注意,可以使用空字符串进行连接,相当于字符串拼接

  str1 = 'abc1shj23kls99+2kkk'
  print("".join([i for i in str1 if i.isdigit()]))  # join()中参数一定是一个序列
  

• 对不满多少位数的数据,进行重复填充可以用字符串格式化

  # 字符串拼接能够很轻松想到,后三位数字用0进行填补,{字符串:M>N}在左边填充,{字符串:M
  str1 = "py1901"
  # str2 = input("请输入您的代号:")
  str2 = "23"
  print(f"{str1}{str2:0^7}")
  # 尤其注意,用f语句时,不能随意添加空格   ValueError: Invalid format specifier
  

• 用切片来代替,逻辑与

  """
  写程序实现字符串函数find/index的功能(获取字符串1中字符串2第一次出现的位置)
  
  > 例如: 字符串1为:**how are you? Im fine, Thank you!**  , 字符串2为:**you**,  打印**8**
  用切片来代替逻辑连接符
  """
  str1 = "how are you? Im fine, Thank you!"
  str2 = "you"
  for i in range(len(str1) - len(str2) + 1):  # 能取倒数第三个元素,切片使代码简化
      if str1[i: i + len(str2)] == str2:
          print(i)
          break
  else:
      print("字符串1中不包含字符串2")
  

• 判断共有的字符,可以想到集合,集合中的元素可以是任何数据类型.集合的数学运算可以灵活运用,主要针对其中元素的处理.各种数据转换成集合的表现形式,需注意.

  """
      例如: 原字符串: 'how are you? and you?'   旧字符串: 'you'  新字符串:'me'  
      结果: 'how are me? and me?'
      用相同字符串进行分割,然后用相同字符串进行拼接,可以实现替换的功能
      分割之后是一个包含许多小字符串的序列,用列表存储起来
  """
  
  str1 = 'how are you? and you?'
  str2 = 'you'
  str3 = 'me'
  str4 = str1.split(str2) # 用split对原字符串进行切割,可以实现删除相同的元素
  str5 = str3.join(str4)# 用join进行拼接,可以实现添加相同的元素,也可以不添加,添加对象设置为空
  print(str5)
  

函数的几种常识

• 函数的引入: 主要是解决相同功能,代码重复的问题.可以实现代码的优化和复杂功能的实现.
• 函数: 实现某一特定功能的代码的封装
• 系统函数: 由系统创建好的函数
• 自定义函数: 由程序员自己创建的函数

函数的规则

• def 关键字

• 函数名 由程序员自己决定,两个要求,和三个规范,同变量命名一样

• 形参列表: 可以有任意个变量,是外部和函数内部实现关联的关键

• 函数说明文档: 本质上是一个多行注释

• 函数体: 函数体是实现函数功能的代码 , 和def 保持一个缩进的多行代码

  """
  def  函数名(形参列表):
  	函数说明文档
  	函数体
  """	
  def factorial(num):
      """
      用for循环连续求乘积时,可以定义一个变量来保存
      最终结果,初始值为1,最终返回
      确定循环范围时,需注意从1开始取,num能取到
      :param num:
      :return:product
      """
      product = 1
      for i in range(1, num + 1):
          product *= i
      return product
  

函数调用

• 函数名(实参列表)

• 实参列表是通过形参列表从函数外部传入到函数内部的载体

• 定义函数时不会指定函数体,调用函数的时候才会执行函数体

  """
  函数调用过程:
  1)回到函数定义位置
  2)传参
  3)执行函数体
  4)确认返回值
  5)回到函数调用的位置接着往后执行
  """
  

函数参数

• 根据调用函数时,实参传入方式不同,可以将实参分为位置参数和关键字参数

• 位置参数,直接将多个数据用逗号隔开,让实参和形参从位置上一一对应

• 关键字参数,调用函数时,以形参名1 = 实参1,形参名2 = 实参2…形式存在

  def func1(a, b, c):
      print(f'a:{a}, b:{b}, c:{c}')
  
  
  # 位置参数
  func1(10, 20, 30)
  func1(20, 10, 30)
  
  # 关键字参数
  func1(a=10, b=20, c=30)
  func1(b=20, a=10, c=30)
  # 位置参数和关键字参数一起用
  func1(10, b=20, c=30)
  # func1(a=10, 20, c=30)     # 报错！
  # func1(20, a=10, c=30)     # 报错！
  

• 位置参数只能在关键字参数前面,同时位置参数的位置从创建函数时就已经确定了

• 不管以什么方式传参,必须保证每个参数都有值,并且每个参数只有一个值(除非参数有默认值)

• 参数默认值: 在定义函数时,可以给形参赋予初始值,此时便是默认值,有默认值的参数在函数调用时,可以不对其进行传参

  def func2(a=1, b=2, c=3): # 给参数设置默认值
      # a = 10, b = 20
      print(f'a:{a}, b:{b}, c:{c}')
  

• 没有默认值的参数在函数调用时,必须传入参数

• 使用位置参数时,位置必须明确,相当于一个萝卜一个坑

• 定义函数时,可以选择对参数类型进行说明

  def func7(str1: str, list1: list, str2=''):  #使用参数加冒号,再加变量类型对齐进行说明
      pass
  
  # 也可以对变量赋予初始值,对齐进行说明
  

返回值

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

• 定义函数时,需不需要添加返回值,有两点参考,一是考虑函数体有没有新的数据产生,二是考虑在后续的编程过程中需不需要这些数据

  """
  返回值就是:    return  关键字  后面的表达式的值(函数内部产生的数据,不返回,无法在函数外面使用)
  
  返回多个值 
  return  num1 , num2
  """
  

• 在使用函数表达式时,实际上就已经返回了函数输出的数据,这个时候可以定义一个新的变量来接受返回的数据.返回数据的类型有很多,具体根据函数体进行分析

  # 求两个数的和以及平均值
  def sum_average(num1, num2):
      s1 = num1 + num2
      avg = s1 / 2
      return s1, avg
  

• 函数可以返回空值None

• 最关键的是识别有没有新数据的产生,并且新数据在后续是否发挥编程意义

• 每次函数调用时,都会执行函数体,并输出返回值

作业

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

   """
   编写一个函数，交换指定字典的key和value。 
   例如:dict1={'a':1, 'b':2, 'c':3}  -->  dict1={1:'a', 2:'b', 3:'c'}  
   """
   
   dict1 = {'a': 1, 'b': 2, 'c': 3}
   
   
   def exchange_key_value(dict_one: dict):
       result = {value: key for key, value in dict_one.items()}
       return result
   
   
   dict1 = exchange_key_value(dict1)
   print(dict1)
   

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

   """
   编写一个函数，提取指定字符串中所有的字母，然后拼接在一起产生一个新的字符串 
    例如: 传入'12a&bc12d-+'   -->  'abcd'  
   """
   str1 = '12a&bc12d-+'
   
   
   def all_letter(str_one: str):
       result = "".join([i for i in str_one if i.islower() or i.isupper()])
       return result
   
   
   new_str = all_letter(str1)
   print(new_str)
   
   

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

   """
   写一个自己的capitalize函数，能够将指定字符串的首字母变成大写字母
     例如: 'abc' -> 'Abc'   '12asd'  --> '12asd'
   """
   str1 = '12bc'
   
   
   def upper_first(str_one: str):
       result = f"{str_one[0].upper() if str_one[0].islower() else str_one[0]}{str_one[1:]}"
       return result
   
   
   new_str = upper_first(str1)
   print(new_str)  
   

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

   """
   写一个自己的endswith函数，判断一个字符串是否已指定的字符串结束 
   例如: 字符串1:'abc231ab' 字符串2:'ab' 函数结果为: True
   字符串1:'abc231ab' 字符串2:'ab1' 函数结果为: False
   """
   str1 = 'abc231ab'
   str2 = 'ab'
   
   
   def end_letter(str1="", str2=""):
       result = True if str1[-len(str2):] == str2 else False
       return result
   
   
   result1 = end_letter(str1, str2)
   print(result1)
   

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

   """
   写一个自己的isdigit函数，判断一个字符串是否是纯数字字符串   
      例如: '1234921'  结果: True
            '23函数'   结果: False
            'a2390'    结果: False
   """
   
   str_1 = '123492hg1'
   
   
   def all_digit(str_1=""):
       result = ["True" if "0" <= i <= "9" else "False" for i in str_1]
       if "False" in set(result):
           result = False
       else:
           result = True
       return result
   
   
   consequence = all_digit(str_1)
   print(consequence)
   
   

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

   """
   写一个自己的upper函数，将一个字符串中所有的小写字母变成大写字母
   例如: 'abH23好rp1'   结果: 'ABH23好RP1'  
   """
   str_1 = 'abH23好rp1'
   
   
   def upper_char(str_one: str):
       """
       ord函数获取小写字母的ASCLL码,和大写字母差值为32,可以进行转换,chr(ASCLL码)转换成对应的字符
       """
       
       result = "".join([chr(ord(i )-32) if i.islower() else i for i in str_one])   
       return result
   
   
   consequence = upper_char(str_1)
   print(consequence)
   
   

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

   """
   写一个自己的rjust函数，创建一个字符串的长度是指定长度，原字符串在新字符串中右对齐，剩下的部分用指定的字符填充  
      例如: 原字符:'abc'  宽度: 7  字符:'^'    结果: '^^^^abc'
           原字符:'你好吗'  宽度: 5  字符:'0'    结果: '00你好吗'
   """
   str_1 = 'abc'
   str_2 = '^'
   width = 7
   
   
   def format_str(str_one="", str_two="", num_width=0):
       # result = f"{str_one:{str_two}>{num_width}}"  可以通过大括号对固定数据进行传入参数
       return str_one.rjust(num_width, str_two)
   
   
   consequence = format_str(str_1, str_2, width)
   print(consequence)
   

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

   """
   写一个自己的index函数，统计指定列表中指定元素的所有下标，如果列表中没有指定元素返回-1
      例如: 列表: [1, 2, 45, 'abc', 1, '你好', 1, 0]  元素: 1   结果: 0,4,6  
           列表: ['赵云', '郭嘉', '诸葛亮', '曹操', '赵云', '孙权']  元素: '赵云'   结果: 0,4
           列表: ['赵云', '郭嘉', '诸葛亮', '曹操', '赵云', '孙权']  元素: '关羽'   结果: -1        
   """
   list1 = ['赵云', '郭嘉', '诸葛亮', '曹操', '赵云', '孙权']
   char_first = 1
   
   
   def index(list_1: list, char):
       new_list = [i for i in range(len(list1)) if list1[i] == char]
       if new_list == []:
           return -1
       else:
           return new_list
   
   
   result = index(list1, char_first)
   print(result) 
   

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

   """
   写一个自己的len函数，统计指定序列中元素的个数 
       例如: 序列:[1, 3, 5, 6]    结果: 4
            序列:(1, 34, 'a', 45, 'bbb')  结果: 5  
            序列:'hello w'    结果: 7
   """
   list1 = [1, 3, 5, 6]
   
   
   def count(list_1):
       count_sum = 0
       for i in list_1:
           count_sum += 1
       return count_sum
   
   
   result = count(list1)
   print(result)
   
   

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

    """
    写一个自己的max函数，获取指定序列中元素的最大值。如果序列是字典，取字典值的最大值
      例如: 序列:[-7, -12, -1, -9]    结果: -1   
           序列:'abcdpzasdz'    结果: 'z'  
           序列:{'小明':90, '张三': 76, '路飞':30, '小花': 98}   结果: 98
    """
    list1 = {'小明': 90, '张三': 76, '路飞': 30, '小花': 98}
    
    
    def max_char(list_1):
       if type(list_1) == dict:
           new_list = list(list_1.values())
           max_value = new_list[0]
           for i in new_list:
               if i > max_value:
                   max_value = i
       else:
           max_value = list_1[0]
           for i in list_1:
               if i > max_value:
                   max_value = i
       return max_value
    
    
    result = max_char(list1)
    print(result)
    
    

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

    """
    写一个函数实现自己in操作，判断指定序列中，指定的元素是否存在  
        例如: 序列: (12, 90, 'abc')   元素: '90'     结果: False
             序列: [12, 90, 'abc']   元素: 90     结果: True     
    """
    
    list1 = (12, 90, 'abc')
    char = '90'
    
    
    def char_in(list_1, char_one):
        for i in list_1:
            if i == char_one:
                return True
            else:
                return False
    
    
    result = char_in(list1, char)
    print(result)
    

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

    """
    写一个自己的replace函数，将指定字符串中指定的旧字符串转换成指定的新字符串
        例如: 原字符串: 'how are you? and you?'   
        旧字符串: 'you'  新字符串:'me'  
        结果: 'how are me? and me?'
    """
    
    first_str = 'how are you? and you?'
    old_str = 'you'
    new_str = 'me'
    
    
    def result_str(first_str, old_str, new_str):
        result = new_str.join(first_str.split(old_str))   # 分割之后本身就是列表,列表外面添加中括号,会报错,实际上只有一个元素
        return result
    
    
    consequence = result_str(first_str, old_str, new_str)
    print(consequence)