[Python知识库]Python学习之旅--函数

1,函数介绍

• 目的: 函数的作用

• """
  函数的作用:
      1, 代码复用性提高了
      2, 可维护性提高
  """
  

2,函数定义

• 目的: 知道函数的组成, 定义, 调用

• 操作流程:

  """
  函数定义:
      def 函数名(参数1:类型1, 参数2:类型2) -> 声明返回值类型
          ...
          return 返回值
  
  函数组成说明:
      1, def 函数名需要遵守标识符规则; 必须
      2, 参数(形式参数);  不必须
      3, 声明返回值类型;   不必须
      4, return 返回值;  不必须
          
  函数的调用:
      函数名(参数1,参数2)
      
  函数种类(参数,返回值):
      1, 无参数,无返回值
      2, 无参数,有返回值
      3, 有参数,无返回值
      4, 有参数,有返回值
      
  注意点:
      1, 函数定义好之后,不调用,不会执行
  """""
  
  #1,定义一个函数,没有参数,没有返回值
  def haha():
      print("你调用了哈哈")
  
  # haha()
  
  #2, 定义函数, 无参数,有返回值
  def get_age() -> int:
      return 30
  
  # age = get_age()
  # print(age)
  
  #3, 定义函数,有参数,无返回值
  # def get_num(name:str,age:int):
  #     print("我的名字是{}, 今年{}岁了".format(name,age))
  #
  # get_num("迪丽热巴",23)
  
  #4,定义函数,4, 有参数,有返回值
  def get_sum(num1:int,num2:int) -> int:
  
      return num1 + num2
  
  result = get_sum(100,200)
  print("result = {}".format(result))
  

3,函数参数

• 目的: 掌握函数参数的其他几种用法

• 操作流程

  """
  函数参数设置方式:
      1, 缺省参数, 可以设置默认值
      2, 不定长参数,元祖格式(*args),可以接受多个参数,
          如果需要指明特定参数,需要将参数写在最前面
      3, 不定长参数,字典格式(**kwargs),可以接受多个键值对
  
  """
  
  #1, 定义函数, 设置缺省参数(可以不用传递,其实就是一个默认值)
  def test(num1:int,num2:int = 100) -> int:
      return num1 + num2
  
  # print(test(10,1))
  
  #2, 定义参数, 设置不定长参数(不确定函数需要设置几个参数), args元祖类型,可以接受多个参数
  # name为指定参数, 一定要写在最前面
  def test2(name:str,*args):
      print(args)
      print(name)
      # print(type(args))
  
  # test2("张三",2,3,4,5,6,10)
  
  #3, 定义参数, 设置不定长参数字典格式; **kwargs可以接受字典
  def test3(*args,**kwargs):
      print(args)
      print(kwargs)
  
  test3("张三",2,3,4,5,6,10,a=10,b=20,c=30)
  

4,函数返回值

• 目的: 掌握函数返回值的作用

• 操作流程

  """
  返回值特点:
      1, 一旦进行return,那么函数马上结束,函数后面的内容不会执行
      2, 如果return多个值, 会将多个值封装成一个元祖进行返回
  """""
  
  #1,定义函数,设置返回值
  def sum(num1,num2):
      return num1 + num2 # 一旦进行return,那么函数马上结束,函数后面的内容不会执行
      # print("hahahha")
  
  # print(sum(10,20))
  
  #2,定义函数,设置多个返回值(元祖格式)
  def sum2(num1,num2) -> tuple:
      return num1 + num2, num1 * num2, num1-num2
  
  print(sum2(3,5))
  

5,函数嵌套

• 目的: 掌握函数的嵌套调用

• 操作流程

  #1,开始上班
  def start_work(name):
      coding(name)
  
  #2,写代码
  def coding(name:str):
      print("{},开始写代码".format(name))
      debug()
  
  #3,调试程序
  def debug():
      print("调试程序")
      online()
  
  #4,项目上线
  def online():
      print("项目上线鸟,好开心")
  
  start_work("雷军")
  

6,函数练习

• 目的: 掌握函数的练习

• 操作流程

  """
  需求: 给定列表[1,2,3,4,5]
       求出他们列表和, 平均数
  """""
  
  #1, 求和
  def get_sum(list) -> int:
      """求给定列表的和"""
      sum = 0
      for i in list:
          sum += i # sum = sum +i
      return sum
  
  #2, 求平均数
  def get_avg(list,sum):
      return sum / len(list)
  
  sum = get_sum([1,2,3,4,5])
  avg = get_avg([1,2,3,4,5],sum)
  print("sum = {}, avg = {}".format(sum,avg))
  
  # 获取函数的文档注释
  print(get_sum.__doc__) # 求给定列表的和
  print(get_avg.__doc__) # None
  

7,局部全局变量

• 目的: 掌握python中局部,全局变量的特点

• 操作流程

  """
  全部变量&局部变量:
      1, 在函数外部定义的变量, 全局变量
      2, 在函数内部定义的变量是局部变量
      
  注意点:
      1, 在函数内部默认使用的是局部变量(就近原则)
      2, 在函数外部使用的变量是全局变量
      3, 局部变量提权(全局变量), global 变量名
  
  """""
  #1,定义变量,全局变量(特点: 定义在函数外部, 其他的函数都能使用)
  a = 10
  
  def test():
      # global a #提权, 将局部变量转换成全局变量
      a = 20
      print("test a = {}".format(a))
  
  def test2():
      a = 30
      print("test2 a = {}".format(a))
  
  test()
  test2()
  
  #输出a, 值是多少? 10
  print("函数外部 a = {}".format(a))
  

8,变量引用

• 目的: 知道python中的变量引用两种方式(数值传递, 引用传递)

• 操作流程

  #1, 数值引用, 可以通过系统函数id()查看变量的内存地址
  # a = 10
  # b = a
  # a = 20
  # print("b = {}".format(b))
  # print(id(a)) # 输出内存地址
  # print(id(b))
  
  #2, 地址引用; 两个人完全穿的是同一条"裤子"
  # a = [1,2,3]
  # b = a
  # a.append("哈哈")
  # b.append("嘻嘻")
  # print(a)
  # print(id(a)) # 两者内存地址完全一样
  # print(id(b))
  
  #3, 函数数值传递
  # def change_number(num1):
  #     num1 = 10
  #
  # num1 = 5
  # change_number(num1)
  # print("num1 = {}".format(num1))
  
  #4, 引用传递
  def change_list(a):
      a.append("哈哈")
  
  list = [1,2,3,4]
  change_list(list)
  print(list)
  

9,可变和不可变类型

• 目的: 知道哪些数据类型是可变的(引用), 哪些是不可变的(数值)

• 操作流程

  """ ################一, 数值传递  #################### """""
  # 数字, 字符串, 元祖
  #1,字符串数值传递 -> 不可变类型
  # a = "张三"
  # b = a
  # a = "李四"
  # print(b)
  
  #2, 元祖数值传递
  # tuple1 = (1,2,3)
  # tuple2 = tuple1
  # tuple1 = (4,5,6)
  # print(tuple2)
  
  """ ################二, 引用传递  #################### """""
  # 可变类型: 列表, 字典
  # list1 = ["a","b","c"]
  # list2 = list1
  # list1.append("d")
  # print(list2)
  
  dict1 = {
      "name":"迪丽热巴",
      "age":33
  }
  dict2 = dict1
  dict1["sex"] = "女"
  print(dict2)
  
  

总结

1, 函数作用, 代码复用, 方便维护

2, 函数定义, def 函数名(参数: int = 10) -> 类型: return 返回值

3, 函数参数, 缺省值, 不定长*args, **kwargs

4, 函数嵌套, 函数内部调用其他函数

5, 局部变量,全局变量, 局部变量, global 变量名

6, 变量引用, 数值引用,不可变(数字,字符串,元祖), 地址引用,可变(列表,字典)