Python基础：函数
创建一个自定义函数是通过关键字def来声明的，格式如下：
def 函数名(参数):"""函数的文档说明（可选）"""函数体 # 要执行的代码return 返回值 # 可选#简化def 函数名(参数):函数体return 返回值
一、什么是函数？
就像工厂里的某台机器。机器有一个功能，比如“榨汁机”。
函数 = 工厂里的机器
参数 = 原料
函数体 = 加工过程
返回值 = 产品
调用函数 = 按下按钮
函数的好处
代码复用：写一次，到处用。
代码更清晰：让程序分块，结构更明了。
便于维护：修改函数内部逻辑时，只需改一处。
1.函数的参数
无参数
def greet():print("果汁！")greet() #果汁有参数
def greet(name):print(f"你好，{name}！")greet("Python") #你好，Python！多个参数
def add(a, b):return a + bresult = add(3, 5)
print(result) # 8
默认参数
def greet(name="Python"):print(f"你好，{Python}！")greet() # 没有传参数 -> 你好，Python！
greet("小红") # 你好，Python！
2.函数的返回值
def square(x):return x * xresult = square(4)
print(result) # 16#无参数def square():return 20result = square()
print(result) # 203.函数的作用域
局部变量：在函数里定义的，只在函数里有效。
def test():y = 5 # 局部变量print(y)test() #5
print(y) #name 'y' is not defined全局变量：在函数外定义的，整个程序都能用。
x = 10 # 全局变量def test():y = 5 # 局部变量print(x) # 可以访问全局变量print(y)test()
"""
10
5
"""
print(x) #10二.匿名函数（lambda）
调用一次就不再被调用了的函数，就像一次性手套一样。
square = lambda x: x * x
print(square(5)) # 25#等价于def square(x):return x * x
print(square(5)) # 25三.常用的7个内置函数
1. len() — 获取对象的长度
作用：len() 用来 计算对象的长度，可以用于字符串、列表、元组等多种数据结构。
# 字符串示例
s = "Hello, World!"
print(f"字符串的长度: {len(s)}") # 输出: 13# 列表示例
lst = [1, 2, 3, 4, 5]
print(f"列表的长度: {len(lst)}") # 输出: 5# 元组示例
tup = (10, 20, 30)
print(f"元组的长度: {len(tup)}") # 输出: 3# 字典示例
d = {"name": "Alice", "age": 25, "city": "New York"}
print(f"字典的长度: {len(d)}") # 输出: 3# 集合示例
s = {1, 2, 3, 4, 5}
print(f"集合的长度: {len(s)}") # 输出: 5# 自定义对象示例
class MyClass:def __init__(self, items):self.items = itemsdef __len__(self):return len(self.items)obj = MyClass([1, 2, 3, 4])
print(f"自定义对象的长度: {len(obj)}") # 输出: 4
# 字符串的长度
text = "Python"
print(len(text)) # 6# 列表的长度
numbers = [1, 2, 3, 4]
print(len(numbers)) # 4
适用场景：在数据分析中常用来查看数据集、列表、数组等的大小，比如查看 DataFrame 中有多少行或列。
2. range() — 生成一个数字序列
作用：range() 用来生成一个整数序列，常用作 for 循环的迭代器。它可以生成一个从起始值到结束值的整数序列，可以用来遍历数组、生成索引等。
range(start, stop, step)
start（可选）：开始值，默认为 0。stop：结束值（不包括），循环会生成小于stop的所有数字。step（可选）：步长，默认为 1。即每次生成的数字之间的差值。
# 示例1：基本用法
print("示例1：基本用法")
for i in range(5):print(i)
print()
"""
0
1
2
3
4
"""
# 示例2：指定开始值和结束值
print("示例2：指定开始值和结束值")
for i in range(2, 8):print(i)
print()
"""
2
3
4
5
6
7
"""# 示例3：指定步长
print("示例3：指定步长")
for i in range(0, 10, 2):print(i)
print()
"""
0
2
4
6
8
"""# 示例4：逆向迭代
print("示例4：逆向迭代")
for i in range(10, 0, -2):print(i)
print()
"""
10
8
6
4
2
"""# 示例5：生成数字并转换为列表
print("示例5：生成数字并转换为列表")
numbers = list(range(1, 6))
print(numbers)
"""
[1, 2, 3, 4, 5]
"""
适用场景：在爬虫和数据处理过程中，常用
range()来批量处理数据，或者在批量抓取时设置步长等。
3. map() — 函数式编程中的批量操作
作用：map() 函数可以将一个 函数应用到序列的每一个元素上，返回一个迭代器。常用于批量数据处理时，将一个操作应用到列表或其它可迭代对象的每个元素。
map(function, iterable, *iterables)
function：要应用的函数，可以是lambda，也可以是现成的函数（int、str.strip、abs…）。iterable：一个可迭代对象（比如列表、元组、字符串、生成器……）。*iterables：表示还可以额外传入多个可迭代对象。星号
*这里的意思是“可变参数”，即不限个数。所以
map()最少要 2 个参数（函数 + 一个 iterable），最多可以很多参数（函数 + 多个 iterable）。
可以把 map() 想象成 流水线机器：
function= 加工步骤iterable(s)= 原料（1 批或多批）map= 把原料一个个丢进加工机，吐出新产品
"""
Python 内置函数 map() 全面示例
"""# ======================
# 1. 基本用法
# ======================# 单个 iterable
nums = [1, 2, 3, 4]
squares = map(lambda x: x * x, nums)
print("平方:", list(squares)) # [1, 4, 9, 16]# 函数/方法引用
words = [" Alice ", "Bob", " CAROL"]
print("去除空格:", list(map(str.strip, words)))
print("转小写:", list(map(str.lower, ["A","B","C"])))# 多个 iterable（逐项并行，按最短长度）
import operator
a = [1, 2, 3]
b = [10, 20, 30, 40]
print("并行加法:", list(map(operator.add, a, b))) # [11, 22, 33]# ======================
# 2. 惰性与一次性消费
# ======================
m = map(int, ["1", "2", "3"])
print("第一次消费:", list(m)) # [1, 2, 3]
print("再次消费:", list(m)) # [] 已空# ======================
# 3. 常见模式
# ======================# 批量类型转换/清洗
raw = [" 1 ", " 2", "003 "]
clean_ints = list(map(lambda s: int(s.strip()), raw))
print("批量转换:", clean_ints)# 文本规范化
names = ["alice", "BOB", "Carol"]
normalized = list(map(str.title, map(str.strip, names)))
print("规范化:", normalized)# 组合多个序列
xs, ys = [1,2,3], [4,5,6]
sums = list(map(operator.add, xs, ys))
prods = list(map(operator.mul, xs, ys))
print("按位加:", sums)
print("按位乘:", prods)# 构造字典
keys, vals = ["a","b","c"], [1,2,3]
d = dict(map(lambda kv: (kv[0], kv[1]), zip(keys, vals)))
print("字典:", d)# ======================
# 4. 易踩坑演示
# ======================# 错误处理
def safe_int(s):try:return int(s)except ValueError:return Noneprint("安全转换:", list(map(safe_int, ["1", "x", "2"]))) # [1, None, 2]# ======================
# 5. 小练习
# ======================
print("练习1:", list(map(lambda s: int(s)**2, ["1","2","3"]))) # [1,4,9]
print("练习2:", list(map(str.upper, map(str.strip, [" a ","B "," c"])))) # ['A','B','C']
print("练习3:", list(map(operator.add, [1,2,3], [10,20,30,40]))) # [11,22,33]
适用场景：在数据分析和处理时，
map()可以非常方便地应用某些函数（如取平方、转换单位等）到数据集的每个元素。
4. filter() — 过滤数据
作用：filter() 函数用于 过滤数据，返回一个迭代器，包含那些满足条件的元素。过滤条件是通过一个 返回布尔值的函数 来指定的。
# filter() 基本用法示例小抄
# 语法: filter(function, iterable)
# 返回: 一个迭代器(要用 list() 转换成列表才能直接看到)# 1. 过滤偶数
nums = [1, 2, 3, 4, 5, 6]
def is_even(n):return n % 2 == 0
print(list(filter(is_even, nums))) # [2, 4, 6]# 2. 用 lambda 表达式过滤大于 3 的数
print(list(filter(lambda x: x > 3, nums))) # [4, 5, 6]# 3. 使用 None 去掉所有“假值”(False, 0, '', None, [])
vals = ["a", "", "b", None, 0, "0"]
print(list(filter(None, vals))) # ['a', 'b', '0']# 4. 过滤字典，保留 value > 0 的项
d = {'a': 1, 'b': 0, 'c': 2}
print(dict(filter(lambda kv: kv[1] > 0, d.items()))) # {'a': 1, 'c': 2}# 5. 与 for 循环配合，逐个处理满足条件的元素（惰性）
for x in filter(lambda n: n % 2 == 1, nums):print("odd:", x) # odd: 1, odd: 3, odd: 5# 6. 列表推导式等价写法（更常见）
print([n for n in nums if n % 2 == 0]) # [2, 4, 6]
filter(func, data)保留 func 返回 True 的元素。filter(None, data)去掉所有 假值。通常用
list()把结果变成列表。和列表推导式
[x for x in data if cond(x)]等价。
适用场景：在数据处理和爬虫中，常用
filter()来筛选满足特定条件的数据。例如：过滤掉一些无效或格式不符合的数据。
5. sorted() — 对数据进行排序
作用：sorted() 函数用来 对可迭代对象进行排序，返回一个排好序的列表。它不仅支持升序排序，也支持按指定规则排序。
sorted(iterable, key=None, reverse=False)把一个可迭代对象排序，返回一个新的列表。
iterable：要排序的数据（list/tuple/字符串/字典等）。
key：排序依据的函数（比如按长度排序
key=len）。reverse：是否倒序（默认 False，升序；True 倒序）。
# 1. 基本排序（数字）
nums = [5, 2, 9, 1]
print(sorted(nums)) # [1, 2, 5, 9]# 2. 字符串排序（按字母）
letters = ["b", "a", "d", "c"]
print(sorted(letters)) # ['a', 'b', 'c', 'd']# 3. reverse=True 倒序
print(sorted(nums, reverse=True)) # [9, 5, 2, 1]# 4. 按长度排序字符串
words = ["python", "is", "fun"]
print(sorted(words, key=len)) # ['is', 'fun', 'python']# 5. 字典排序（只对 key 排序）
d = {"b": 2, "a": 5, "c": 1}
print(sorted(d)) # ['a', 'b', 'c']# 6. 对字典按 value 排序
print(sorted(d.items(), key=lambda kv: kv[1]))
# [('c', 1), ('b', 2), ('a', 5)]# 7. 复杂数据排序：按第二个元素排序
pairs = [(1, "b"), (3, "a"), (2, "c")]
print(sorted(pairs, key=lambda x: x[1]))
# [(3, 'a'), (1, 'b'), (2, 'c')]
适用场景：在数据分析中，
sorted()可以用来对数据进行排序，常用于时间序列分析或排名等。
6. zip() — 多个可迭代对象组合
作用：zip() 可以将多个 可迭代对象（如列表、元组等）中的元素一一对应地组合在一起，返回一个迭代器，常用来 配对数据。
# 合并两个列表
names = ["Alice", "Bob", "Charlie"]
scores = [90, 80, 85]zipped = zip(names, scores)
print(list(zipped)) # [('Alice', 90), ('Bob', 80), ('Charlie', 85)]
适用场景：在数据分析中，
zip()可以用来 合并数据集，比如将姓名和成绩结合成一个数据对，或者处理两个不同数据源的联合分析。
7. sum() — 求和
作用：sum() 函数用于对一个可迭代对象中的元素进行求和，返回它们的总和。
numbers = [1, 2, 3, 4, 5]
total = sum(numbers)
print(total) # 15
适用场景：在数据分析中，
sum()常用于快速计算数据集中某一列的总和，特别是金融数据分析中用于计算总收益、总支出等。