Python学习——Python 与 C 语法对比5（函数）

承接上篇：

Python学习——Python 与 C 语法对比1（输出、注释、运算符、数字型）-CSDN博客

Python学习——Python 与 C 语法对比2（非数字型）-CSDN博客

Python学习——Python 与 C 语法对比3（条件控制）-CSDN博客

Python学习——Python 与 C 语法对比4（循环）-CSDN博客

Python 与 C 函数语法对比

语法特性	Python	C
函数定义	def function_name(parameters): # Function body	return_type function_name(parameter_types) {    // Function body }
参数类型注解	def function_name(param1: int, param2: str) -> float: # Function body	int function_name(int param1, char* param2){     // Function body }
默认参数值	def function_name(param1=0, param2=''): # Function body	void function_name(int param1 = 0, char* param2 = NULL) {    // Function body }
可变参数	def function_name(*args): # Function body	void function_name(int argc, ...) {    // Function body }
关键字参数	def function_name(**kwargs): # Function body	C语言不支持关键字参数，但你可以通过结构体和函数指针来实现类似的功能。
Lambda表达式	lambda x: x + 1	C语言本身并没有lambda表达式，需要使用函数指针或者结构体来实现类似的功能。
匿名函数	lambda x: x * x	C语言中的匿名函数（使用函数指针） int square(int x) { return x * x; }
递归调用	def factorial(n):   if n == 0:     return 1   else:     return n * factorial(n-1)	int factorial(int n) {   if (n == 0) {     return 1;   } else {     return n * factorial(n - 1);   } }

举例：函数定义、默认参数

Python：

def greet(name):
    return f"Hello, {name}!"

print(greet("Alice"))  # 输出 "Hello, Alice!"

C：

#include <stdio.h>
#include <string.h>

char* greet(const char* name) {
    static char greeting[50];
    sprintf(greeting, "Hello, %s!", name);
    return greeting;
}

int main() {
    printf("%s\n", greet("Alice"));  // 输出 "Hello, Alice!"
    return 0;
}

举例：可变参数

Python：

def print_numbers(*args):
    for num in args:
        print(num)

print_numbers(1, 2, 3, 4, 5)  # 输出 1 2 3 4 5

C：

#include <stdio.h>
#include <stdarg.h>

void print_numbers(int count, ...) {
    va_list args;
    va_start(args, count);
    for (int i = 0; i < count; i++) {
        int num = va_arg(args, int);
        printf("%d ", num);
    }
    va_end(args);
    printf("\n");
}

int main() {
    print_numbers(5, 1, 2, 3, 4, 5);  // 输出 1 2 3 4 5
    return 0;
}

举例：关键字参数

Python：

def print_info(name, age, city):
    print(f"Name: {name}, Age: {age}, City: {city}")

print_info(age=25, name="Alice", city="New York")  # 输出 "Name: Alice, Age: 25, City: New York"

C：

#include <stdio.h>
#include <string.h>

typedef struct {
    char *name;
    int age;
    char *city;
} Person;

void print_info(Person p) {
    printf("Name: %s, Age: %d, City: %s\n", p.name, p.age, p.city);
}

int main() {
    Person alice = {"Alice", 25, "New York"};
    print_info(alice);
    return 0;
}

在这个示例中，我们定义了一个名为Person的结构体，用于存储姓名、年龄和城市信息。然后我们创建了一个print_info函数，它接受一个Person类型的参数，并打印出相应的信息。在main函数中，我们创建了一个名为alice的Person实例，并调用print_info函数来打印她的详细信息。

举例：lambda

Python：

add = lambda x, y: x + y
print(add(3, 5))  # 输出 8

C：

#include <stdio.h>

int add(int x, int y) {
    return x + y;
}

int main() {
    printf("%d\n", add(3, 5));  // 输出 8
    return 0;
}

举例：匿名函数

Python：

# 定义一个匿名函数，接受两个参数x和y，返回它们的和
add = lambda x, y: x + y

# 使用匿名函数计算3和5的和
result = add(3, 5)
print(result)  # 输出8

C：

#include <stdio.h>

// 定义一个函数类型，接受两个整数参数，返回它们的和
typedef int (*func_ptr)(int, int);

// 定义一个普通函数，实现上述类型的功能
int add(int x, int y) {
    return x + y;
}

int main() {
    // 声明一个函数指针变量，指向add函数
    func_ptr add_ptr = add;

    // 使用函数指针调用add函数
    int result = add_ptr(3, 5);
    printf("%d\n", result);  // 输出8

    return 0;
}

 举例：递归调用

Python：

def factorial(n):
    if n == 0:
        return 1
    else:
        return n * factorial(n - 1)

print(factorial(5))  # 输出 120

C：

#include <stdio.h>

int factorial(int n) {
    if (n == 0) {
        return 1;
    } else {
        return n * factorial(n - 1);
    }
}

int main() {
    printf("%d\n", factorial(5));  // 输出 120
    return 0;
}