【python】函数的使用

短命女 2024-02-21 11:14 41阅读 0赞

## 一、函数与方法的区别 ##

*  直接调用的是函数
 *  通过对象点出来的是方法

>  *  在Python中，函数和方法都是一段可重复使用的代码块，可以执行特定的任务。它们之间的区别在于它们的调用方式和应用场景。
>  *  函数是独立的代码块，可以通过函数名直接调用。函数可以接受输入参数，并返回一个结果。函数可以在任何地方定义，不依赖于类或对象。
>  *  方法是类中的函数，与特定的对象关联。方法必须通过对象或类进行调用。方法可以访问对象的属性，并对其进行操作。在调用方法时，方法自动传入关联的对象作为第一个参数，通常被称为 self。
>  *  可以将函数视为独立的工具，而方法更像是与对象密切相关的行为。

> **下面是函数和方法的使用：**
> 
>     # 函数示例：
>     def calculate_sum(a, b):
>         return a + b
>     
>     result = calculate_sum(3, 4)
>     print(result)  # 输出：7
>     
>     # 方法示例：
>     class Calculator:
>         def __init__(self, value):
>             self.value = value
>     
>         def add(self, number):
>             self.value += number
>     
>         def get_value(self):
>             return self.value
>     
>     # 创建 Calculator 对象
>     calculator = Calculator(10)
>     
>     # 调用方法
>     calculator.add(5)
>     result = calculator.get_value()
>     print(result)  # 输出：15

## 二、函数的定义 ##

>  *  使用关键字 def 来进行函数定义，后面指定函数名，还可在括号内指出参数。
>  *  在Python中，函数是一段可重复使用的代码块，用于执行特定的任务。函数通常接受输入参数，并根据参数执行相应的操作，并最终返回一个结果。

> 函数的定义通常包括以下几个部分：
> 
> 1.  函数头：函数头包括关键字 `def`，后跟函数名和一对圆括号 `()`。函数名是我们给函数起的名称，用于标识和调用函数。括号内可以包含参数，用于接收函数调用时传递的输入值。
> 2.  函数体：函数体是函数的主要部分，包括一组执行特定任务的语句。函数体通常由缩进块组成，用于标识函数体的范围。在函数体中，可以用来处理参数、执行操作，并最终返回结果。
> 3.  返回值：函数可以选择性地返回一个结果。使用关键字 `return` 后跟要返回的值，可以将该值传递给函数的调用者。如果没有明确指定返回值，则函数默认返回 `None`。

> 下面是函数定义示例：
> 
>     def greet(name):
>         """打印欢迎信息，使用传入的名字"""
>         print("Hello, " + name + "!")
>     
>     # 调用函数
>     greet("Alice")  # 输出：Hello, Alice!
> 
> 在以上示例中，`greet`是一个函数，接受一个参数 `name`，用于打印一条欢迎信息。在函数体内，使用 `print`语句将欢迎信息输出到控制台。然后，我们调用函数 `greet`，并将参数 `"Alice"` 传递给它。
> 
> **【注意】**函数定义后，可以在程序的任何地方调用函数，以重复执行其中的代码块。

> 定义一个函数，输出两个数字相加的结果
> 
>     def res(a, b):
>      print(f'a={a}')
>      print(f'b={b}')
>      print(f'结果={a + b}')
>      res(1, 2)

>  *  Python对于参数的传入是没有类型限制的
>  *  不过可以通过给参数添加类型，提示调用时应传入的类型
> 
>     res(a: int, b: int)

## 三、传参的几种方法 ##

> 1.  位置传参
>     
>         res(1, 2)
> 2.  关键字传参
>     
>         res(a=1, b=2)
> 3.  缺省参数
>     
>         res(a: int, b: int = 10)
>          res(1)
>     
>     > 参数具备默认值的时候可以不传，具备默认值的参数需要放在没有默认值的参数后面
> 4.  可变参数
>     
>         def res(*nums: int):
>          val = 0
>          for i in nums:
>          val += i
>          print(val)
>     
>         def res(**nums: int):
>          val = 0
>          for i in nums.values():
>          val += i
>          print(val)

## 四、函数的返回值 ##

*  返回值不限类型，所以不需要指定返回类型
 *  使用 return 关键字
 *  可以通过元组的形式返回多个值

编写一个函数，接受多个参数，返回最大值，最小值与总和

def res(*nums: int):
     val = 0
     val_max = nums[0]
     val_min = nums[0]
     for i in nums:
     val += i
     val_min = i if i < val_min else val_max;
     val_max = i if i > val_max else val_max;
     return val, val_min, val_max

## 五、函数的注释 ##

查看python中关于函数的说明： help()

def res(a, b):
     """
    两数相加
    :param a: 数字
    :param b: 数字
    :return: 结果
    """
     return a + b

## 六、其他 ##

### 1、函数嵌套： ###

*  定义求和函数
 *  在求和函数上完成平均值函数

### 2、变量作用域： ###

*  全局变量
 *  局部变量

### 3、递归调用： ###

**计算1+n的和**

def res(target: int):
     if target <= 0:
     return '0'
     if target == 1:
     return 1
     return target + res(target - 1)

**计算斐波那契数列**

def res(target: int):
     if target <= 0:
     return '0'
     if target <= 2:
     return 1
     return res(target - 1) + res(target - 2)

## 七、Lambda表达式 ##

### 1、作用 ###

>  *  Lambda 表达式是 Python 中的一种小而简洁的匿名函数表示方法。与常规函数不同，Lambda 表达式可以在不定义函数名称的情况下创建函数对象。
> 
> Lambda 表达式的作用有以下几个方面：
> 
> 1.  简化函数定义：Lambda 表达式的语法简洁，可以用一行代码定义简单的函数，不需要使用 `def` 关键字创建函数。
> 2.  函数作为参数：Lambda 表达式可以作为其他函数的参数使用，尤其在需要传递简短函数逻辑的场景下非常方便。例如，在排序、映射、过滤等函数中经常会用到 Lambda 表达式作为参数。
> 3.  代码的可读性：Lambda 表达式通常用于短小的函数逻辑，可以在代码中直接表示这些逻辑，避免了创建单独函数的繁琐过程。这样可以使代码更加简洁，更易于阅读和理解。
> 4.  功能性扩展：Lambda 表达式可以与其他函数一起使用，增强了代码的功能性。通过使用 Lambda 表达式，我们可以在需要的地方快速创建并使用函数，而不必为每个小任务都创建新的函数定义。
> 
> Lambda 表达式的基本语法是：`lambda 参数: 表达式`。其中，参数指定函数的输入参数，表达式指定函数的逻辑和返回值。
> 
> 下面是一个示例，展示了如何使用 Lambda 表达式来定义一个简单的加法函数：
> 
>     add = lambda x, y: x + y
>     
>     result = add(3, 5)
>     print(result)  # 输出：8
> 
> `lambda x, y: x + y` 定义了一个匿名函数，接受两个参数 `x` 和 `y`，并返回它们的和。然后，我们将这个 Lambda 表达式赋值给变量 `add`，并在后续代码中使用 `add` 调用这个函数。最终，输出结果为 8。

### 2、实例 ###

相当于匿名函数，可以简化目前的函数，在 java 中的流式操作与函数接口有体现。

//常规
    Runnable r1=new Runnable() {
     @Override
     public void run() {
     System.out.println("你好");
     }
     };
     //lambda表达式
    Runnable r2=()->{
     System.out.println("你好");
     };

但是 python中的表达式只能存在一行代码，使用 python 中的lambda来简化函数

# 未简写
    def res():
     return 10
     # 简写
    res = lambda: 10
    形式： lamdba 参数 : 执行操作/返回值

**编写一个函数，接受两个参数，并返回最大值**

def res(a, b):
     return a if a > b else b
     res = lambda a, b: a if a > b else b

**使用 lambda 对字典数据进行排序**

persons = [
     {"name": "张三", "age": 20},
     {"name": "李四", "age": 17},
     {"name": "王麻子", "age": 21}
     ]
     persons.sort(key=lambda p: p['age'], reverse=True)

**将一个元素中所有的值翻倍 map**

nums = [1, 2, 3, 4, 5, 6, 7]
     m = map(lambda a: a * 2, nums)
     for i in m:
     print(i)

**让集合中的对应位置进行相加**

nums1 = [1, 2, 3, 4, 5, 6, 7]
     nums2 = [2, 3, 4, 5, 6, 7, 8]
     m = map(lambda a, b: a + b, nums1, nums2)
     for i in m:
     print(i)

**对集合进行筛选**

nums = [1, 2, 3, 4, 5, 6, 7]
     f = filter(lambda a: a > 5, nums)
     for i in f:
     print(i)