---
## 一、函数基础
```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 |
---
