资讯详情

---

## 一、函数基础

```python
# 定义
def login():
    print("系统登录成功")
login()                          # 系统登录成功

# return 返回值
def login():
    return
print(login())                   # None

def login():
    return 111
print(login())                   # 111

def login():
    return 111, "你好"
print(login())                   # (111, '你好')
```

**总结：** 无返回值返回 `None`，一个返回值直接返回，多个返回值以 `tuple` 返回。

- Python 函数多返回值是天然支持的，Java 要返回多个值得用对象、数组或 `Map` 包装。

## 二、函数参数的五种形式

### 2.1 必备参数

```python
# 传参个数和类型要一致
def sum(num1, num2, num3):
    return num1 + num2 + num3
print(sum(11, 22, 33))           # 66
```

### 2.2 默认参数

```python
# 注：默认参数必须在位置参数之后
# def sum(num=3, num2): ... 会报错
def sum(num1, num2, num3=10):
    return num1 + num2 + num3
print(sum(11, 22))               # 43
print(sum(11, 22, 33))           # 66
```

### 2.3 可变参数 `*args`

```python
# 传入的值数量可变化，可不传、可传1个、可传多个
def sum(*args):                  # 以 tuple 接收
    sumNum = 0
    for arg in args:
        sumNum += arg
    return sumNum
print(sum(11, 22))               # 33
print(sum(11, 22, 33))           # 66
```

### 2.4 关键字参数 `**kwargs`

```python
def fun1(**kwargs):
    print(kwargs, type(kwargs))
fun1(name="wxy", age=18)         # {'name': 'wxy', 'age': 18} <class 'dict'>
```

- `*args` 收集成 `tuple`，`**kwargs` 收集成 `dict`，这是 Python 函数的灵活性来源。
- Java 没有等价语法，最接近的是可变参数 `Object... args`，但只支持位置参数。

## 三、作用域

```python
# 全局变量
str = "hello"
def hello():
    print(str)
hello()                          # hello

# 局部变量
def hello():
    str = "你好"
    print(str)
hello()                          # 你好

# global 修改全局变量
print(str)                       # hello
def hello():
    global str
    str = "你好"
    print(str)
hello()                          # 你好
print(str)                       # 你好

def study():
    global score                 # 加上 global，局部变量变成全局变量
    score = 80
study()
print(score)                     # 80
```

### nonlocal：声明外层的局部变量

```python
# 只能在嵌套函数中使用，影响上一级函数的值
in1 = 10
def outer():
    in1 = 20
    def inner():
        nonlocal in1
        in1 = 30
        def inner1():
            in1 = 40
            print("inner1 局部变量:", in1)
        inner1()
        print("inner 局部变量:", in1)
    inner()
    print("outer nonlocal 局部变量:", in1)
outer()
print("全局变量:", in1)
```

- `global` 影响全局，`nonlocal` 影响上一层函数作用域，Java 没有这种细分。

## 四、匿名函数（lambda）

```python
# 语法：函数名 = lambda 形参 : 返回值(表达式)
# 普通函数
def sum(a, b, c):
    return a + b + c
print(sum(1, 2, 3))              # 6

# 简化为 lambda
sum = lambda a, b, c: a + b + c
print(sum(1, 2, 3))              # 6

# 无参数
name = lambda: "wxy"
print(name())                    # wxy

# 1个参数
name = lambda name: name
print(name("wxy1"))              # wxy1

# 默认参数
name = lambda name, age=18: (name, age)
print(name("wxy2"))              # ('wxy2', 18)
print(name("wxy2", 20))          # ('wxy2', 20)

# 关键词参数
name = lambda **kwargs: print(kwargs)
name(name="wxy2", age=20)        # {'name': 'wxy2', 'age': 20}

# 结合 if else
comp = lambda a, b: "a比b大" if a > b else "a比b小"
print(comp(8, 10))               # a比b小
```

- Python 的 `lambda` 只能写一个表达式，类似 Java 的 `()->` 箭头函数，但限制更多（不能写多行）。

## 五、内置函数与高阶函数

```python
print(abs(-10))                  # 10 绝对值
print(sum([1, 2, 3]))            # 6 求和（支持 list/tuple/set）
print(max(1, 2, 3))              # 3
print(max(1, 2, 3, key=abs))     # 3
print(min(1, 2, 3, key=abs))     # 1
```

### 5.1 zip：打包成 tuple

```python
li1 = [1, 2, 3]
li2 = [4, 5, 6]
li3 = [4, 5]
print(zip(li1, li2))             # <zip object at 0x...>
for key in zip(li1, li2):
    print(key)                   # (1, 4) (2, 5) (3, 6)
print(list(zip(li1, li2)))       # [(1, 4), (2, 5), (3, 6)]

# 元素不一致，按短的返回
print(list(zip(li1, li3, li2)))  # [(1, 4, 4), (2, 5, 5)]
```

### 5.2 map：每个元素执行函数

```python
se1 = {1, 2, 3}
mapDef = lambda a: a + 1
print(list(map(mapDef, se1)))    # [2, 3, 4]
```

### 5.3 reduce：累计计算

```python
from functools import reduce
li1 = [1, 2, 3]
add = lambda a, b: a + b
print(reduce(add, li1))          # 6 计算过程：1+2=3 -> 3+3=6
```

- `map / reduce / filter` 是函数式编程三件套，对应 Java 8 的 `Stream.map / reduce / filter`。
- `zip` 是 Python 独有的多可迭代对象打包能力，Java 没有直接对应。

## 六、拆包

```python
# 含义：对于函数中的多个返回数据，去掉 tuple/list/dict，直接获取里面的数据
tua = (1, 2, 3, 4)
a, b, c, d = tua
print(a, b, c, d)                # 1 2 3 4

# * 取多个元素
a, *b = tua
print(a, b)                      # 1 [2, 3, 4]

def fun(a, b, *args):
    print(a, b, args)            # 1 2 (3, 4, 5, 6, 7)
    print(a, b, *args)           # 1 2 3 4 5 6 7
    a, b, *c = args
    print(a, b, c)               # 3 4 [5, 6, 7]
fun(1, 2, 3, 4, 5, 6, 7)

# 传参时拆包
dep1 = (1, 2, 3, 4, 5, 6, 7)
fun(*dep1)
```

- 拆包是 Python 独有的语法糖，Java 想做同样的事得手写下标。

## 七、异常处理

```python
# raise 自定义异常
# raise Exception("wxy抛出异常")  # Exception: wxy抛出异常

# 捕获异常：遇到异常时，代码还会继续执行，程序不会终止
try:
    raise Exception("wxy抛出异常")
except Exception as e:
    print(e)                     # wxy抛出异常
print(111)                       # 111
```

- Python 的 `try/except` 对应 Java 的 `try/catch`，`raise` 对应 `throw`。
- Python 异常不强制声明（无 `throws` 关键字），更灵活但也更容易漏处理。

## 八、模块

```python
# 含义：一个 .py 文件就是一个模块，导入一个模块本质上就是执行一个 py 文件
# 分类：内置模块、第三方模块、自定义模块

# 导入模块
import py02
print(py02.age)                  # 22

# 指定导入模块中的变量或方法
from py03 import dic
print(py03.dic)                  # {'name': 'wxy', 'age': 18, 'tel': 123456}
print(dic)                       # {'name': 'wxy', 'age': 18, 'tel': 123456}

# 常用内置模块：random、time、os、logging
# 第三方模块安装：pip install pygame
# 卸载：pip uninstall pygame
# 查看已安装：pip list
```

- Python 的模块系统比 Java 的 `import` 灵活，可以导入变量、函数，不只是类。
- ⚠️ 不要过多使用 `from ... import`，可能造成命名冲突，有冲突时使用最后一个模块导入的值。

---

## 📌 与 Java 的对比

| 概念 | Java | Python |
|------|------|--------|
| 函数定义 | `[修饰符] 返回类型 方法名()` | `def 函数名():` |
| 多返回值 | 用对象/数组包装 | 直接 `return a, b` |
| 可变参数 | `int... nums` | `*args` |
| 关键字参数 | 不支持 | `**kwargs` |
| 匿名函数 | Lambda（可多行） | `lambda`（单表达式） |
| 异常 | `try/catch/finally` + `throws` | `try/except/finally` |
| 模块导入 | `import 包.类` | `import 模块` / `from 模块 import *` |
| 包管理 | Maven / Gradle | pip |

---