[TOC]

函数

• 函数就是将一段具有独立功能的代码块整合到一个整体并命名，在需要的位置调用这个函数名称即可实现对应的功能

  函数定义

• 函数是通过def关键字来定义的
• main+空格直接生成main代码块，通常是用来调试代码的，也就是说将定义好的函数放到main代码块处进行调用，方便管理

  基本语法

  def function_name(parameters):
      # 函数体
      # 可以包含多行代码
      return experssion

  def: 关键字，用于声明一个函数 function_name: 函数的名字，遵循Python标识符的命名规则 parameters: 圆括号内的参数列表，用于接收传递给函数的值。参数之间用逗号分隔 return: 可选的关键字，用于指定函数执行完毕后返回的值。如果没有return语句，则默认返回None 示例

  # 定义函数时同时定义了接收用户指定数据的参数a和b，a和b是形参
  def add_sum1(a,b):
      result = a + b
      print(result)
  # 调用函数时传入了真实的数据10，20，真实的数据为实参
  add_sum1(10,20)

• return：return返回多个数据时，默认是元组类型
• 使用return可以退出当前函数，导致return下方的代码会停止执行
• return语句可以用于在函数内部控制流程，比如在找到满足条件的第一项时立即返回结果，避免不必要的循环或计算。

  示例

  def add(a, b):
      return a + b
   
  result = add(5, 3)
  print(result)  # 输出: 8

• 定义函数时，对于大部分的情况的入参可以定义一个默认值，有默认值的是非必填参数，没有默认值的是必填参数。有默认值的入参定义必须在最后

  示例

  def greet(name, greeting="Hello"):
      """向某人发出问候，使用默认的问候语或自定义的问候语"""
      print(f"{greeting}, {name}!")
   
  # 调用函数，使用默认的问候语
  greet("Alice")  # 输出: Hello, Alice!
   
  # 调用函数，使用自定义的问候语
  greet("Bob", "Hi")  # 输出: Hi, Bob!

  函数说明文档

• 连敲三个引号"""+回车，会自动生成
• 声明入参类型的好处是：函数内部使用入参时可以自动联想出该类型下的方法

  基本语法

  def 函数名(参数):
  '''
  说明文档的位置
  '''
  代码
  ...

  示例

  def greet(name):
      """
      向指定的人打招呼。
   
      参数:
          name (str): 要打招呼的人的名字。
   
      返回:
          str: 包含问候信息的字符串。
      """
      return f"Hello, {name}!"
   
  # 访问函数的docstring
  print(greet.__doc__)

  变量作用域

• 变量作用域指的是变量生效的范围，主要分为两类：局部变量和全局变量
• python中变量的作用域遵循LEGB规则的顺序来搜索：局部作用域-->封闭作用域-->全局作用域-->内置作用域

  局部变量

• 局部变量是定义在函数体内部的变量，即只在函数体内部生效
• 局部变量的作用：在函数体内部，临时保存数据，当函数被调用完成后，则销毁局部变量

  示例

  def testA():
      a = 100
      print(a)
   
  testA() # 100
  # 变量a是定义在函数 testA 内部的变量，在函数外部访问则理解报错
  print(a) # 报错：name 'a' is not defined

• 在Python中局部变量和全局变量同名时，局部变量会遮蔽（shadow）全局变量，将只能访问到局部变量，而无法直接访问同名的全局变量

  示例

  x = 5  # 这是一个全局变量
   
  def my_function():
      x = 10  # 这是一个局部变量，它遮蔽了全局的 x
      print(x)  # 将输出局部变量的值 10
   
  my_function()  # 调用函数，输出 10
  print(x)  # 在函数外部，输出全局变量的值 5

  全局变量

• 全局变量是在函数体内，外都能生效的变量
• 全局变量定义在所有函数之外
• 可以在程序的任何地方被访问。
• 生命周期与程序相同，从程序开始运行到程序结束

  示例

  # 定义一个全局变量a
  a = 100
  def testA():
      print(a) #访问全局变量a，并打印变量a存储的数据
  def testB():
      print(a) #访问全局变量a，并打印变量a存储的数据
   
  testA() # 100
  testB() # 100

• 如果想在函数内部访问并修改全局变量，即使存在同名的局部变量，需要使用 global 关键字来声明你想操作的是全局变量

  示例

  x = 5
   
  def my_function():
      global x  # 声明 x 是全局变量
      x = 10  # 修改全局变量 x 的值
      print(x)  # 输出全局变量的新值 10
   
  my_function()  # 调用函数，输出 10
  print(x)  # 在函数外部，输出全局变量的值 10

  函数的参数

  位置参数

• 位置参数:调用函数的时候根据函数定义的参数位置来传递参数
• 在函数定义时，位置参数没有默认值，因此调用函数时必须按照参数的顺序依次传入相应的值
• 传递和定义参数的顺序及个数必须一致

  示例

  def user_info(name,age,gender):
  print(f'您的名字是{name},年龄是{age},性别是{gender}')
  user_info('Alice',20,'女')

  关键字参数

• 关键字参数: 函数调用，通过’键=值‘形式加以指定
• 允许在调用函数时通过参数名来指定值，而不是仅仅依赖于参数的位置
• 当位置参数和关键字参数同时存在时，位置参数必须先于关键字参数，但关键字参数之间不存在先后顺序

  示例

  def user_info(name,age,gender):
  print(f'您的名字是{name},年龄是{age},性别是{gender}')
  # 调用函数
  user_info('Alice',age=20,gender='女') #位置参数要放在关键字参数的前面，关键字参数不要求顺
  序，无所谓
  user_info('Alice',gender='女',age=20)

  缺省参数

• 缺省参数:缺省参数也叫默认参数，用于定义函数，为参数提供默认值，调用函数时可不传该默认参数的值
• 所有位置参数必须出现在默认参数前，包括函数定义和调用

  示例

  def user_info(name, age, gender='女'):
      print(f'您的名字是{name},年龄是{age},性别是{gender}')
  # 调用函数，使用默认参数，不传gender
  user_info('Alice', 20) # 输出：您的名字是Alice,年龄是20,性别是女
  # 调用函数，更改默认的参数值
  user_info('luci', age=23, gender='女') # 输出：您的名字是luci,年龄是23,性别是女
  # 调用函数，关键字参数不区分顺序，只要在位置参数后面就可以
  user_info('lili', gender='女', age=25) # 输出：您的名字是lili,年龄是25,性别是女

  不定长参数

• 不定长参数指的是在函数定义时允许函数接收可变数量的参数

  非关键字可变参数 *args

• *args允许函数接收任意数量的位置参数
• 所有额外的位置参数都会被封装到一个名为args的元组中
• 如果参数名不是args，那么所有额外的位置参数将被封装到所给定的变量名对应的元组中

  示例

  def sum_all(*numbers):
      total = 0
      for number in numbers:
          total += number
      return total
   
  # 调用函数
  print(sum_all(1, 2, 3, 4, 5))  # 输出: 15

  关键字可变参数 **kwargs

• **kwargs允许函数接收任意数量的关键字参数
• 所有额外的关键字参数都会被封装到一个名为kwargs的字典中
• 如果参数名不是kwargs，那么所有额外的关键字参数将被封装到所给定的变量名对应的字典中

  示例

  def print_employee_info(**kwargs):
      for key, value in kwargs.items():
          print(f"{key}: {value}")
   
  print_employee_info(name="John", age=30, department="IT")
   
  # 输出：
  name: John
  age: 30
  department: IT

• 对于那些不确定个数的有对应关系的入参定义可以使用**kwargs

  匿名函数lambda

• 匿名函数是一种没有名称的简短函数，通常用于需要临时使用函数的地方
• 这种类型的函数是通过lambda关键字定义的，因此也被称为lambda函数
• lambda 函数可以具有任意数量的参数，但只能有一个表达式
• 匿名函数不需要使用 def 关键字定义完整函数
• 匿名函数的定义要求：一个函数内容有且仅一行代码时，并且有返回值，才能使用匿名函数

  基本语法

  lambda 参数 : 表达式
   
  lambda arguments: expression

  * 参数可以是一个或者多个，用逗号,分隔，但只能返回一个表达式的值 示例

  # 函数
  def add(x,y):
      return x + y
  print(add(5,3))
   
  add = lambda x, y: x + y
  print(add(5, 3))  # 输出: 8

• 如果一个函数经常性会被调用，那么是不需要把定义成匿名函数的
• 如果仅被调用那么一次，没必要去定义一个函数，此时就可以使用匿名函数

  lambda的排序操作

• 排序操作：当使用列表的sort()方法或sorted()函数时，lambda函数常用来定义自定义的排序规则

  示例

  data = [('apple', 2), ('orange', 1), ('banana', 3)]
  sorted_data = sorted(data, key=lambda x: x[1])
  print(sorted_data)  # 输出: [('orange', 1), ('apple', 2), ('banana', 3)]

  高阶函数

  map()

• map()是一个内置的高阶函数，它接收一个函数和一个或多个序列作为参数，然后将这个函数依次应用于这些序列的每个元素上，产生一个迭代器
• 通常我们会将这个迭代器转换为列表、元组或其他类型的容器以便使用

  示例

  list1 = [1, 2, 3]
  list2 = [4, 5, 6]
   
  # lambda函数接受两个参数x和y，分别来自list1和list2，并将它们相加
  summed_list = map(lambda x, y: x + y, list1, list2)
  print(list(summed_list))  # 输出：[5, 7, 9]

  reduce()

• reduce() 函数会对参数序列中元素进行累积。每次func计算的结果继续和序列的下一个元素做累积计算
• 工作流程如下： * 1. 首先取序列中的前两个元素作为function的参数，执行function(a, b)得到结果r * 2. 然后将结果r和序列中的下一个元素作为新的参数再次执行function * 3. 重复此过程直到序列中的所有元素都被处理完毕，最后得到一个单一的结果

  基本语法

  from functools import reduce
  reduce(function, iterable, initializer)

  function：只接受两个参数 iterable：这是要处理的序列，可以是列表、元组等 * initializer：这是一个可选参数，用于指定一个初始值。如果提供了initializer，则它会被当作第一个参数传递给function 示例1

  from functools import reduce
   
  list1 =[1,2,3,4,5]
  result = reduce(lambda x,y:x+y,list1)
  print(result) # 15

  示例2

  from functools import reduce
   
  numbers = [1, 2, 3, 4, 5]
  # reduce()将首先计算10 * 1，然后用结果继续与序列中的其他元素进行运算
  product = reduce(lambda x, y: x * y, numbers, 10)
  print(product)  # 输出：1200

  filter()

• filter()函数用于过滤序列，过滤掉不符合条件的元素，返回一个filter对象。如果要转换为列表，可以使用list()来转换

  基本语法

  filter(function, iterable)

• function：一个接受单个参数的函数，用来测试每个元素是否满足某个条件，如果function为None，则使用布尔转换来过滤元素，即只保留非零和非空的元素
• iterable：一个可迭代对象，如列表、元组、集合等

  示例1

  numbers = [1, 2, 3, 4, 5, 6]
  even_numbers = filter(lambda x: x % 2 == 0, numbers)
  print(list(even_numbers))  # 输出：[2, 4, 6]

  示例2

  items = [0, 1, '', 'hello', [], [1, 2], None]
  filtered_items = filter(None, items)
  # 数字0、空字符串、空列表等会被过滤掉，因为它们在布尔上下文中被认为是False
  print(list(filtered_items))  # 输出：[1, 'hello', [1, 2]]

  enumerate()

• 你在循环中既需要元素又需要元素的索引时，enumerate()就非常有用
• 它会返回一个枚举对象，其中包含了列表或其他可迭代对象的索引和值

  基本语法

  enumerate(iterable, start=0)

  iterable: 可以是任何可迭代的对象，如列表、元组、字符串等 start: 索引的起始值，默认为0 示例

  fruits = ['apple', 'banana', 'cherry']
   
  # 使用 enumerate 函数
  for i, fruit in enumerate(fruits):
      print(f"Index {i}: {fruit}")
   
  # 输出：
  # Index 0: apple
  # Index 1: banana
  # Index 2: cherry