python笔记8

目录

1、函数的定义及调用

2、函数的参数传递

1.位置参数（Positional Arguments）:

2.关键字参数（Keyword Arguments）:

3.默认值参数（Default Arguments）:

4.可变参数（Variable Arguments）:

1.*args（任意数量的位置参数）:

2.**kwargs（任意数量的关键字参数）:

5、不同数据参数的不同传递方式：

3、函数的返回值

4、变量的作用域

1.全局作用域（Global Scope）：

2.局部作用域（Local Scope）：

3.嵌套作用域（Enclosing Scope）：

4.关键字：

5、匿名函数

6、函数的递归

7、内置函数

1、类型转换函数：

2、数学函数：

3、迭代操作函数：

4、其它函数：

---

1、函数的定义及调用

函数是Python中的基本模块，可以实现特定的功能，并在需要时运行。下面，在详细介绍Python函数的定义及调用方式。

函数的定义： 在Python中，可以通过def关键字来定义一个函数。函数定义的基本格式如下：

def function_name(arguments):
    # 函数体
    # 处理逻辑
    return output 

在以上的格式中，function_name 是你要定义的函数的名称，arguments 是你希望传入的参数（可以有多个，用逗号隔开）。函数体是你希望函数执行的一系列Python指令。这些指令将对输入的参数执行一些处理，并返回一个结果。使用return语句可以返回函数结果（如果不写return或者写return但后面为空，则函数返回None）。其中arguments和return output均为可选项，根据实际需求进行使用。

函数的调用： 一旦你定义了一个函数，就可以通过它的名字来调用它，并传入你希望它处理的参数。函数调用的基本格式如下：

output = function_name(input_parameters)

2、函数的参数传递

在Python函数定义中，可以使用位置参数、关键字参数、默认值参数以及可变参数，这些方式提供了函数调用的灵活性和清晰性。下面是对这三种参数的详细解释：

1.位置参数（Positional Arguments）:

• 位置参数是最常见的参数类型，调用函数时，参数的值需要按照函数定义中的顺序传递。
• 必须精确地传递正确数量的参数，否则会引发错误。

  def describe_pet(animal_type, pet_name):
      print(f"I have a {animal_type} named {pet_name}.")
  
  describe_pet('hamster', 'Harry')
  

  输出：

  I have a hamster named Harry.
  

  2.关键字参数（Keyword Arguments）:

• 关键字参数允许函数调用时指定每个参数的名称与值。
• 使用关键字参数时，参数的顺序可以与声明时不同，因为Python解释器能够根据参数名匹配参数值。
• 提高了函数调用的可读性。

def describe_pet(animal_type, pet_name):
    print(f"I have a {animal_type} named {pet_name}.")

describe_pet(pet_name='Harry', animal_type='hamster')

输出：

I have a hamster named Harry.

3.默认值参数（Default Arguments）:

• 定义函数时，可以为参数提供默认值。
• 调用函数时，如果未传递该参数，则使用定义函数时指定的默认值。
• 有默认值的参数应该放在参数列表的末尾。

  def describe_pet(pet_name, animal_type='dog'):
      print(f"I have a {animal_type} named {pet_name}.")
  
  describe_pet(pet_name='Willie')
  

  输出：

  I have a dog named Willie.
  

  4.可变参数（Variable Arguments）:

可变参数（也称为不定参数）允许在函数调用时传递任意数量的参数。这对于当不确定将需要处理多少参数时特别有用。Python提供了两种类型的可变参数：*args 和 **kwargs。

1.*args（任意数量的位置参数）:

• 使用星号（*）前缀定义，表示该函数可以接受任意数量的位置参数。
• 在函数内部，这些参数被存储在一个名为args的元组中。

示例：

def make_pizza(*toppings):
    print("Making a pizza with the following toppings:")
    for topping in toppings:
        print(f"- {topping}")

make_pizza('pepperoni')
make_pizza('mushrooms', 'green peppers', 'extra cheese')

这个函数可以接受任意数量的参数，可以只传递一个参数，也可以传递多个。

2.**kwargs（任意数量的关键字参数）:

• 使用双星号（**）前缀定义，表示该函数可以接受任意数量的关键字参数。
• 在函数内部，这些参数被存储在一个名为kwargs的字典中，其中关键字是参数名，值是参数值。

示例：

def build_profile(first, last, **user_info):
    profile = {}
    profile['first_name'] = first
    profile['last_name'] = last
    for key, value in user_info.items():
        profile[key] = value
    return profile

user_profile = build_profile('albert', 'einstein',
                             location='princeton',
                             field='physics')
print(user_profile)

这个函数接受两个普通参数和任意数量的关键字参数。关键字参数被包装进user_info字典中。

这两种参数可以组合使用，但*args必须位于**kwargs之前，因为它们对应的是参数列表中的位置参数和关键字参数。

5、不同数据参数的不同传递方式：

1. 传值调用（Call by Value）： 在这种方式下，函数的参数值被传递给函数。在函数内部，如果对参数进行修改，不会影响到原始值。Python中的基本数据类型（如整数、浮点数、字符串）采用传值调用。

   def modify_value(x):
       x = x + 10
       print("Inside function:", x)
   
   value = 5
   modify_value(value)
   print("Outside function:", value)
   

   输出：

   Inside function: 15
   Outside function: 5
   

   在函数内部修改了参数 x 的值，但这并不影响外部原始值 value。

2. 传引用调用（Call by Reference）： 在这种方式下，函数的参数是原始值的引用，对参数的修改会影响到原始值。Python中的可变对象（如列表、字典）采用传引用调用。

   def modify_list(my_list):
       my_list.append(4)
       print("Inside function:", my_list)
   
   my_list = [1, 2, 3]
   modify_list(my_list)
   print("Outside function:", my_list)
   

   输出：

   Inside function: [1, 2, 3, 4]
   Outside function: [1, 2, 3, 4]
   

   在函数内部修改了参数 my_list，外部原始值也被修改了。                                                    需要注意的是，虽然Python采用传值调用，但对于可变对象，函数内的修改可能会影响到原始值。这一点与传统的传值调用有所不同。

3、函数的返回值

函数的返回值是函数执行后产生的结果。在Python中，使用关键字return来指定函数的返回值。一个函数可以有零个、一个，或多个返回值。

1. 没有返回值： 

   如果函数没有明确的return语句，或者return后面没有跟任何值，那么默认返回None。

   示例：

   def greet(name):
       print(f"Hello, {name}!")
   
   result = greet("Alice")
   print(result)  # 输出: None
   

2. 单个返回值： 函数可以返回单个值，这个值可以是任意数据类型。

   示例：

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

3. 多个返回值： 一个函数也可以返回多个值，这些值会以元组（tuple）的形式被返回。

   示例：

   def get_info(name, age):
       length = len(name)
       square_age = age ** 2
       return length, square_age
   
   info_result = get_info("Bob", 25)
   print(info_result)  # 输出: (3, 625)
   

   在调用函数后，可以使用多个变量来接收不同位置上的返回值。

   name_length, age_squared = get_info("Bob", 25)
   print(name_length)  # 输出: 3
   print(age_squared)  # 输出: 625
   

   函数的返回值允许在函数执行后将结果传递给调用者，这使得函数可以在程序中完成特定任务并提供结果以供其他部分使用。

4、变量的作用域

1.全局作用域（Global Scope）：

• 在整个程序中定义的变量具有全局作用域。
• 这意味着这些变量可以在程序的任何地方被访问，包括函数内部和外部。
• 在Python中，全局变量是在模块（文件）级别声明的变量。

示例：

global_variable = 10

def print_global():
    print(global_variable)

print_global()  # 输出: 10

2.局部作用域（Local Scope）：

• 在函数内部定义的变量具有局部作用域。
• 这意味着这些变量只能在函数内部访问，函数外部无法直接访问这些变量。

示例：

def local_scope_example():
    local_variable = 20
    print(local_variable)

local_scope_example()  # 输出: 20

# 在这里尝试访问局部变量将引发错误
# print(local_variable)  # 报错：NameError

3.嵌套作用域（Enclosing Scope）：

• 在嵌套函数中，内部函数可以访问外部函数的变量，形成嵌套作用域。
• 外部函数的变量对于内部函数而言是非全局的，但在嵌套范围内可见。

示例：

def outer_function():
    outer_variable = 30

    def inner_function():
        print(outer_variable)

    inner_function()

outer_function()  # 输出: 30

在不同的作用域中，相同名称的变量可以共存而不产生冲突。在访问变量时，编程语言会根据作用域规则进行查找。

4.关键字：

• global：用于在函数内部声明全局变量。
• nonlocal：用于在嵌套函数中声明非局部（但不是全局）变量。

5、匿名函数
 

在Python中，匿名函数是一种使用lambda关键字定义的简洁的、一行的函数。它们通常用于需要函数对象的地方，但又不希望使用标准的、多行的函数定义方式。lambda函数可以接受任何数量的参数，但只能有一个表达式。

匿名函数的基本语法如下：

lambda arguments: expression

这里的arguments是传递给函数的参数列表，expression是函数的操作内容，它的计算结果就是函数的返回值。

匿名函数通常用于短暂的、不需要重复使用的小函数，尤其是在需要函数作为参数的情况下，例如在filter()、map()和sorted()等函数中。例如，使用map()函数将列表中的每个元素都乘以2：

numbers = [1, 2, 3, 4]
doubled = map(lambda x: x * 2, numbers)
print(list(doubled))  # 输出: [2, 4, 6, 8]

这种用法使代码更简洁，更具可读性，尤其是在处理简单的函数时。然而，对于更复杂的逻辑，标准的函数定义通常更合适，因为它们更易于阅读和调试。

6、函数的递归

递归是指函数调用自身的过程。在编程中，递归是一种强有力的工具，用于解决可以被分解成相似子问题的问题。递归函数包含两个主要部分：基本情况（base case）和递归情况（recursive case）。

1. 基本情况（Base Case）：这是递归函数中的停止条件。当函数达到基本情况时，不再进行递归调用，而是返回一个确定的值。

2. 递归情况（Recursive Case）：这是函数调用自身的部分，通常是在解决规模较小但与原问题相似的子问题。

一个简单的例子是计算阶乘的递归函数：

def factorial(n):
    # 基本情况
    if n == 0 or n == 1:
        return 1
    # 递归情况
    else:
        return n * factorial(n-1)

在这个例子中，factorial函数在基本情况下返回1，否则通过调用自身来计算n的阶乘。

使用递归需要小心，因为如果没有正确的基本情况或者递归情况不收敛，可能会导致无限递归，最终导致栈溢出。正确设计递归函数的关键是确保在每次递归调用中问题规模都在缩小，最终达到基本情况。

虽然递归是一种强大的编程技术，但有时迭代（循环）可能更有效，因为递归可能涉及到额外的函数调用开销。在选择使用递归时，需要权衡清晰性和性能。

7、内置函数

1、类型转换函数：

1. int(x) - 将 x 转换为整数。如果 x 是浮点数，它将被截断为整数（去除小数部分），如果 x 是字符串，字符串必须代表整数。

   int(3.5)  # 返回 3
   int("4")  # 返回 4
   
   

2. float(x) - 将 x 转换为浮点数。这对于整数和表示数字的字符串有效。

   float(5)     # 返回 5.0
   float("5.5") # 返回 5.5
   

3. str(x) - 将 x 转换为字符串。

   str(10)    # 返回 "10"
   str(3.14)  # 返回 "3.14"
   

4. bool(x) - 将 x 转换为布尔值。一般来说，任何非零的数字或非空的对象将被转换为 True，而数字0、空对象和 None 将被转换为 False。

   bool(1)     # 返回 True
   bool(0)     # 返回 False
   bool([])    # 返回 False
   bool([1,2]) # 返回 True
   

5. dict([("a", 1), ("b", 2)])  # 返回 {'a': 1, 'b': 2}
   

   list(x) - 将 x 转换为列表。这对于元组、集合、字符串和其他可迭代对象有效。

   list("abc")  # 返回 ['a', 'b', 'c']
   list({1, 2, 3})  # 返回 [1, 2, 3]
   

6. tuple(x) - 将 x 转换为元组。

   tuple([1, 2, 3]) # 返回 (1, 2, 3)
   

7. set(x) - 将 x 转换为集合。这对于列表、元组和字符串有效。

   set([1, 1, 2, 3, 4])  # 返回 {1, 2, 3, 4}
   

8. dict(x) - 通常用于将键值对列表、元组列表或其他形式的键值对转换为字典。

   dict([("a", 1), ("b", 2)])  # 返回 {'a': 1, 'b': 2}
   

   在使用这些转换函数时，重要的是确保提供的数据可以被成功转换成目标类型，否则可能会抛出异常。例如，尝试将不能解析为数字的字符串转换为整数或浮点数将会导致 ValueError。

2、数学函数：
 

Python中的内置数学函数不需要导入任何额外的模块，它们是直接可用的。这些函数提供了一些基本的数学运算和功能。以下是一些重要的内置数学函数及其用途：

1. abs(x) - 返回 x 的绝对值。

   abs(-5)  # 返回 5
   

2. round(x, n) - 四舍五入 x 到 n 位小数。如果不指定 n，默认四舍五入到最近的整数。

   round(3.14159, 2)  # 返回 3.14
   round(3.14159)     # 返回 3
   

3. max(x1, x2, ..., xn) - 返回给定参数中的最大值。

   max(1, 2, 3, 4)  # 返回 4
   

4. min(x1, x2, ..., xn) - 返回给定参数中的最小值。

   min(1, 2, 3, 4)  # 返回 1
   

5. pow(x, y) - 返回 x 的 y 次幂。这类似于 x ** y，但 pow 是内置函数。

   pow(2, 3)  # 返回 8
   

6. sum(iterable, start) - 把 iterable 中的项加起来，并加上 start。默认情况下，start 是0。

   sum([1, 2, 3, 4])     # 返回 10
   sum([1, 2, 3, 4], 10)  # 返回 20
   

7. ivmod(x, y) - 返回一个包含商和余数的元组 (x // y, x % y)。

   divmod(9, 2)  # 返回 (4, 1)
   

   这些函数提供了基本的数学运算能力，非常适合进行简单的数学计算。对于更复杂的数学需求，可以考虑使用像 math、numpy 或 scipy 这样的模块。

3、迭代操作函数：

1. iter(): 返回一个迭代器对象，用于遍历容器对象（如列表、元组、字符串等）。例如：

   my_list = [1, 2, 3]
   my_iterator = iter(my_list)
   

2. sorted()：用于对可迭代对象进行排序。

   my_list = [3, 1, 4, 1, 5, 9, 2]
   sorted_list = sorted(my_list)
   

3. next(): 用于获取迭代器的下一个元素。如果没有元素可用，会触发 异常。例如：StopIteration

   my_iterator = iter([1, 2, 3])
   next_element = next(my_iterator)
   

4. map(): 将函数应用于可迭代对象的每个元素，并返回一个迭代器。例如：

   result = map(lambda x: x * 2, [1, 2, 3])
   

5. zip(): 将多个可迭代对象合并成一个迭代器，每个元素是对应位置上输入对象的元组。例如：

   result = zip([1, 2], ['a', 'b'])
   

6. enumerate(): 枚举可迭代对象的元素，返回元组（索引，元素）。例如：

   result = zip([1, 2], ['a', 'b'])
   

7. sum(): 计算可迭代对象中所有元素的和。例如：

   total = sum([1, 2, 3, 4])
   

8. filter(): 根据给定函数的真值条件过滤可迭代对象的元素，并返回一个迭代器。例如：

   result = filter(lambda x: x > 1, [1, 2, 3])
   

9. reversed()： 返回一个反向迭代器，用于反向遍历序列。

   reversed_list = reversed([1, 2, 3, 4, 5])
   

10. any() 和 all()： 分别检查可迭代对象中是否至少有一个元素为真，或者所有元素都为真。

    my_list = [1, 2, 3, 4, 5]
    any_true = any(element > 0 for element in my_list)
    all_true = all(element > 0 for element in my_list)
    

4、其它函数：

1. len()： 返回对象的长度或元素个数。

   my_list = [1, 2, 3, 4, 5]
   length = len(my_list)
   

2. type()： 返回对象的类型。

   data_type = type(my_list)
   

3. id()： 返回对象的唯一标识符。

   obj_id = id(my_object)
   

4. open()： 打开文件并返回文件对象。

   file = open("example.txt", "r")
   

5. callable()： 检查对象是否可调用（函数、方法等）。

   is_callable = callable(my_function)