有函数如下，如果a = 1, b = 2，然后调用func(a,b)，在函数外a,b的值依然为1,2 def func(a, b): a, b = 3, 4

这是因为函数中的a和b是局部变量，其作用域仅限于函数内部，对它们的修改不会影响到函数外部的a和b变量。如果想要修改函数外的a和b变量，可以将它们定义为全局变量，或者将函数的返回值赋值给a和b。例如：

1. 将a和b定义为全局变量：

a = 1
b = 2

def func():
    global a, b
    a, b = 3, 4

func()
print(a, b)  # 输出结果为 3 4

2. 将函数的返回值赋值给a和b：

a = 1
b = 2

def func(a, b):
    a, b = 3, 4
    return a, b

a, b = func(a, b)
print(a, b)  # 输出结果为 3 4

相关问题

def func（a=128，b=2，*args）

这是一个函数定义，函数名为 `func`，包含三个参数，其中 `a` 和 `b` 是带默认值的参数，`args` 是不定长参数。函数定义中使用了默认参数值 `a=128` 和 `b=2`，如果在函数调用时没有传入这两个参数，则会使用默认值。而 `args` 参数则可以接受任意数量的位置参数，这些位置参数会被打包成一个元组传入函数。

下面是一个示例函数，演示了如何在函数体内使用这些参数：

def func(a=128, b=2, *args):
    print("a =", a)
    print("b =", b)
    print("args =", args)
    result = a * b
    for arg in args:
        result += arg
    return result

在这个示例函数中，我们先打印出三个参数的值，然后对 `a` 和 `b` 进行相乘，接着遍历 `args` 参数并将其中的元素累加到 `result` 变量中，最后返回 `result` 的值。这个函数可以接受任意数量的位置参数，并且在计算 `result` 的时候会将它们全部加起来。

下面是一个调用示例：

result1 = func()
result2 = func(10, 5)
result3 = func(4, 3, 2, 1)

print(result1)  # 输出结果为 256
print(result2)  # 输出结果为 50
print(result3)  # 输出结果为 19

在第一次调用中，因为没有传入任何参数，所以 `a` 和 `b` 都使用了默认值，`args` 参数为空元组，所以计算结果为 `128 * 2 = 256`。在第二次调用中，传入了两个参数 `10` 和 `5`，所以 `a` 被赋值为 `10`，`b` 被赋值为 `5`，`args` 参数仍为空元组，所以计算结果为 `10 * 5 = 50`。在第三次调用中，传入了三个位置参数 `4`、`3` 和 `2`，它们被打包成一个元组 `(4, 3, 2)`，所以 `a` 被赋值为 `4`，`b` 被赋值为 `3`，`args` 参数被赋值为 `(2, 1)`，所以计算结果为 `4 * 3 + 2 + 1 = 19`。

在c++中，类A含有成员对象b，b如何调用类A的非静态成员函数

在 C++ 中，类 A 含有成员对象 b，b 可以通过指向 A 对象的指针或引用来调用 A 的非静态成员函数。例如，假设 A 的非静态成员函数为 `func()`，A 的成员对象为 b，则可以通过以下两种方式调用：

1. 使用指向 A 对象的指针调用 A 的非静态成员函数：

   class B {
   public:
       void func() { /* ... */ }
   };
   
   class A {
   public:
       B b;
       void funcA() { /* ... */ }
   };
   
   A obj;
   A* ptr = &obj;
   obj.funcA(); // 直接调用 A 的成员函数
   obj.b.func(); // 直接调用 B 的成员函数
   ptr->funcA(); // 使用指针调用 A 的成员函数
   ptr->b.func(); // 使用指针调用 B 的成员函数

2. 使用引用调用 A 的非静态成员函数：

   class B {
   public:
       void func() { /* ... */ }
   };
   
   class A {
   public:
       B b;
       void funcA() { /* ... */ }
   };
   
   A obj;
   A& ref = obj;
   obj.funcA(); // 直接调用 A 的成员函数
   obj.b.func(); // 直接调用 B 的成员函数
   ref.funcA(); // 使用引用调用 A 的成员函数
   ref.b.func(); // 使用引用调用 B 的成员函数