函数

函数的定义和调用

Python 函数定义

# Python - 基本函数定义
def greet(name):
    """这是一个简单的问候函数"""
    return f"Hello, {name}!"

# 调用函数
result = greet("Alice")
print(result)  # Hello, Alice!

# 带默认参数的函数
def greet_with_default(name="World"):
    return f"Hello, {name}!"

print(greet_with_default())      # Hello, World!
print(greet_with_default("Bob")) # Hello, Bob!

# 多个参数的函数
def add_numbers(a, b):
    return a + b

result = add_numbers(5, 3)
print(result)  # 8

# 返回多个值
def get_name_and_age():
    return "Alice", 25

name, age = get_name_and_age()
print(f"{name} is {age} years old")

JavaScript 函数定义

// JavaScript - 基本函数定义
function greet(name) {
  return `Hello, ${name}!`;
}

// 调用函数
const result = greet("Alice");
console.log(result); // Hello, Alice!

// 带默认参数的函数
function greetWithDefault(name = "World") {
  return `Hello, ${name}!`;
}

console.log(greetWithDefault()); // Hello, World!
console.log(greetWithDefault("Bob")); // Hello, Bob!

// 多个参数的函数
function addNumbers(a, b) {
  return a + b;
}

const result2 = addNumbers(5, 3);
console.log(result2); // 8

// 返回多个值（使用对象）
function getNameAndAge() {
  return { name: "Alice", age: 25 };
}

const { name, age } = getNameAndAge();
console.log(`${name} is ${age} years old`);

参数传递对比

特性	Python	JavaScript
默认参数	def func(a=1)	function func(a=1)
关键字参数	func(a=1, b=2)	func({a: 1, b: 2})
可变参数	*args	...args
关键字可变参数	**kwargs	对象解构

高级函数特性

Python 高级函数特性

# Python - 可变参数
def sum_numbers(*args):
    return sum(args)

print(sum_numbers(1, 2, 3, 4, 5))  # 15

# Python - 关键字可变参数
def create_person(**kwargs):
    return kwargs

person = create_person(name="Alice", age=25, city="New York")
print(person)  # {'name': 'Alice', 'age': 25, 'city': 'New York'}

# Python - 混合参数
def complex_function(name, age, *args, **kwargs):
    print(f"Name: {name}, Age: {age}")
    print(f"Args: {args}")
    print(f"Kwargs: {kwargs}")

complex_function("Alice", 25, "Engineer", "Python", city="NYC", hobby="coding")

# Python - 函数作为参数
def apply_operation(func, x, y):
    return func(x, y)

def add(a, b):
    return a + b

def multiply(a, b):
    return a * b

print(apply_operation(add, 5, 3))      # 8
print(apply_operation(multiply, 5, 3)) # 15

JavaScript 高级函数特性

// JavaScript - 可变参数
function sumNumbers(...args) {
  return args.reduce((sum, num) => sum + num, 0);
}

console.log(sumNumbers(1, 2, 3, 4, 5)); // 15

// JavaScript - 对象参数
function createPerson({ name, age, city }) {
  return { name, age, city };
}

const person = createPerson({ name: "Alice", age: 25, city: "New York" });
console.log(person); // {name: "Alice", age: 25, city: "New York"}

// JavaScript - 函数作为参数
function applyOperation(func, x, y) {
  return func(x, y);
}

function add(a, b) {
  return a + b;
}

function multiply(a, b) {
  return a * b;
}

console.log(applyOperation(add, 5, 3)); // 8
console.log(applyOperation(multiply, 5, 3)); // 15

匿名函数

Python 匿名函数（Lambda）

# Python - Lambda 函数
square = lambda x: x ** 2
print(square(5))  # 25

# Lambda 在排序中的应用
fruits = ["apple", "banana", "cherry", "date"]
sorted_fruits = sorted(fruits, key=lambda x: len(x))
print(sorted_fruits)  # ['date', 'apple', 'banana', 'cherry']

# Lambda 在 map 中的应用
numbers = [1, 2, 3, 4, 5]
squares = list(map(lambda x: x ** 2, numbers))
print(squares)  # [1, 4, 9, 16, 25]

# Lambda 在 filter 中的应用
even_numbers = list(filter(lambda x: x % 2 == 0, numbers))
print(even_numbers)  # [2, 4]

# 多参数 Lambda
add = lambda x, y: x + y
print(add(3, 4))  # 7

# Lambda 在 reduce 中的应用
from functools import reduce
sum_all = reduce(lambda x, y: x + y, numbers)
print(sum_all)  # 15

JavaScript 匿名函数

// JavaScript - 箭头函数
const square = (x) => x ** 2;
console.log(square(5)); // 25

// 箭头函数在排序中的应用
const fruits = ["apple", "banana", "cherry", "date"];
const sortedFruits = fruits.sort((a, b) => a.length - b.length);
console.log(sortedFruits); // ['date', 'apple', 'banana', 'cherry']

// 箭头函数在 map 中的应用
const numbers = [1, 2, 3, 4, 5];
const squares = numbers.map((x) => x ** 2);
console.log(squares); // [1, 4, 9, 16, 25]

// 箭头函数在 filter 中的应用
const evenNumbers = numbers.filter((x) => x % 2 === 0);
console.log(evenNumbers); // [2, 4]

// 多参数箭头函数
const add = (x, y) => x + y;
console.log(add(3, 4)); // 7

// 箭头函数在 reduce 中的应用
const sumAll = numbers.reduce((sum, num) => sum + num, 0);
console.log(sumAll); // 15

// 立即执行函数表达式 (IIFE)
const result = (() => {
  const x = 10;
  const y = 20;
  return x + y;
})();
console.log(result); // 30

匿名函数对比

特性	Python Lambda	JavaScript 箭头函数
语法	lambda x: x**2	x => x**2
多参数	lambda x, y: x+y	(x, y) => x+y
多行	不支持	支持（需要大括号和 return）
this 绑定	不适用	自动绑定
构造函数	不能	不能

函数式编程特性

Python 函数式编程

# Python - 高阶函数
def compose(*functions):
    def inner(arg):
        for f in reversed(functions):
            arg = f(arg)
        return arg
    return inner

def add_one(x):
    return x + 1

def multiply_by_two(x):
    return x * 2

def square(x):
    return x ** 2

# 组合函数
composed = compose(square, multiply_by_two, add_one)
result = composed(3)  # ((3 + 1) * 2) ** 2 = 64
print(result)

# Python - 装饰器
def timer(func):
    import time
    def wrapper(*args, **kwargs):
        start = time.time()
        result = func(*args, **kwargs)
        end = time.time()
        print(f"{func.__name__} took {end - start:.4f} seconds")
        return result
    return wrapper

@timer
def slow_function():
    import time
    time.sleep(1)
    return "Done"

slow_function()

JavaScript 函数式编程

// JavaScript - 高阶函数
const compose =
  (...functions) =>
  (arg) =>
    functions.reduceRight((acc, fn) => fn(acc), arg);

const addOne = (x) => x + 1;
const multiplyByTwo = (x) => x * 2;
const square = (x) => x ** 2;

// 组合函数
const composed = compose(square, multiplyByTwo, addOne);
const result = composed(3); // ((3 + 1) * 2) ** 2 = 64
console.log(result);

// JavaScript - 装饰器（需要 Babel 或 TypeScript）
function timer(func) {
  return function (...args) {
    const start = performance.now();
    const result = func.apply(this, args);
    const end = performance.now();
    console.log(`${func.name} took ${(end - start).toFixed(4)} seconds`);
    return result;
  };
}

const slowFunction = timer(function () {
  return new Promise((resolve) => {
    setTimeout(() => resolve("Done"), 1000);
  });
});

slowFunction();

闭包

Python 闭包

# Python - 闭包
def outer_function(x):
    def inner_function(y):
        return x + y
    return inner_function

add_five = outer_function(5)
result = add_five(3)  # 8
print(result)

# 闭包的实际应用
def counter():
    count = 0
    def increment():
        nonlocal count
        count += 1
        return count
    return increment

my_counter = counter()
print(my_counter())  # 1
print(my_counter())  # 2
print(my_counter())  # 3

JavaScript 闭包

// JavaScript - 闭包
function outerFunction(x) {
  return function (y) {
    return x + y;
  };
}

const addFive = outerFunction(5);
const result = addFive(3); // 8
console.log(result);

// 闭包的实际应用
function counter() {
  let count = 0;
  return function () {
    return ++count;
  };
}

const myCounter = counter();
console.log(myCounter()); // 1
console.log(myCounter()); // 2
console.log(myCounter()); // 3

练习

1. 创建一个计算器函数，支持加、减、乘、除操作

参考答案：

# Python
def calculator(a, b, op):
    if op == '+':
        return a + b
    elif op == '-':
        return a - b
    elif op == '*':
        return a * b
    elif op == '/':
        return a / b
    else:
        return None
print(calculator(3, 2, '+'))

// JavaScript
function calculator(a, b, op) {
  switch (op) {
    case "+":
      return a + b;
    case "-":
      return a - b;
    case "*":
      return a * b;
    case "/":
      return a / b;
    default:
      return null;
  }
}
console.log(calculator(3, 2, "+"));

2. 使用 Lambda 函数对列表进行排序和过滤

参考答案：

# Python
lst = [5, 2, 9, 1]
sorted_lst = sorted(lst, key=lambda x: -x)
filtered_lst = list(filter(lambda x: x > 3, lst))
print(sorted_lst)
print(filtered_lst)

// JavaScript
let arr = [5, 2, 9, 1];
let sortedArr = arr.slice().sort((a, b) => b - a);
let filteredArr = arr.filter((x) => x > 3);
console.log(sortedArr);
console.log(filteredArr);

3. 实现一个装饰器来测量函数执行时间

参考答案：

# Python
import time
def timer(func):
    def wrapper(*args, **kwargs):
        start = time.time()
        result = func(*args, **kwargs)
        end = time.time()
        print(f"耗时: {end - start:.6f} 秒")
        return result
    return wrapper
@timer
def foo():
    time.sleep(0.5)
foo()

// JavaScript
function timer(fn) {
  return function (...args) {
    const start = Date.now();
    const result = fn(...args);
    const end = Date.now();
    console.log(`耗时: ${(end - start) / 1000} 秒`);
    return result;
  };
}
const foo = timer(() => setTimeout(() => {}, 500));
foo();

4. 创建一个闭包来管理计数器

参考答案：

# Python
def make_counter():
    count = 0
    def inc():
        nonlocal count
        count += 1
        return count
    return inc
counter = make_counter()
print(counter())
print(counter())

// JavaScript
function makeCounter() {
  let count = 0;
  return function () {
    count++;
    return count;
  };
}
const counter = makeCounter();
console.log(counter());
console.log(counter());

5. 比较 Python 和 JavaScript 的函数特性差异

参考答案：

• Python 支持默认参数、可变参数、装饰器、闭包、lambda 表达式。
• JavaScript 支持默认参数、rest 参数、箭头函数、闭包、高阶函数。
• Python 有装饰器语法，JS 没有原生装饰器（但可用高阶函数实现类似功能）。

下一步

现在你已经了解了 Python 的函数编程，接下来我们将学习模块和包的使用。