函数

什么是函数？函数是带名字的代码块，用于完成具体的工作。写出一个函数后，就可以一直调用。

定义函数，函数的基本组成：

1.1 向函数传递参数

向函数中传递任意参数，这样打印出的结果就可以根据自己的选择，做出改变。即是下一节讲到的形参

1 #向函数传递信息

2

3 defgreet_user(username):4 """显示简单的问候语"""

5 print("hello," + username + "!")6

7 greet_user('python')

打印结果：

hello,python!

2、形参与实参

什么是形参？顾名思义，形参就是形式上的参数，可以理解为数学的X，没有实际的值，通过别人赋值后才有意义。相当于变量。

什么是实参？顾名思义，实参就是实际意义上的参数，是一个实际存在的参数，可以是字符串或是数字等。

以上面的例子介绍下什么是形参和实参：

就是在函数名中定义一个形参，然后在函数调用的时候，给函数名中的形参传递一个实际的参数，这个就变为实参。这样的话执行函数体内容时就会执行对应的操作。

注意：传入实参时，一定要加上引号，否则会报错。

greet_user(python)

NameError: name'python' is not defined

3、传递实参（位置实参、关键字实参、默认值、等效的函数调用、避免参数错误）

使用背景：

函数定义中可能包含多个实参，而向函数传递实参的方式有很多，位置实参和关键字实参等。

3.1、位置实参

调用函数时，必须将函数调用中的每个实参都关联到函数定义中的一个形参。关联方式是基于实参的顺序，这被称作位置实参

1 #位置实参

2 defdescribe_pet(animal_type,pet_name):3 """显示宠物信息"""

4 print("\nI have a" + animal_type + ".")5 print("My" + animal_type + "'s name is" + pet_name.title() + ".")6

7 describe_pet('dog','harry')

执行结果：

I have a dog.

My dog's name is Harry.

3.1.1 可以多次调用函数

1 defdescribe_pet(animal_type,pet_name):2 """显示宠物信息"""

3 print("\nI have a" + animal_type + ".")4 print("My" + animal_type + "'s name is" + pet_name.title() + ".")5

6 describe_pet('dog','harry')7

8 #可以多次调用

9 describe_pet("cat",'coo')10 describe_pet('pig','echo')

执行结果：

1 I have a dog.2 My dog's name is Harry.

3

4 I have a cat.5 My cat's name is Coo.

6

7 I have a pig.8 My pig's name is Echo.

3.1.2 实参的位置也很重要，本末倒置可不好

describe_pet('coo','dog')

执行结果：

I have a coo.

My coo's name is Dog.

3.2、关键字参数

关键字实参 是传递给函数的名称：值对。直接将形参与实参关联起来，这样就不存在顺序问题（不会像上一个例子一样出现搞笑的结果）。

示例：

1 2、关键字实参2 defdescribe_pet(animal_type,pet_name):3 """显示宠物信息"""

4 print("\n关键字实参示例：")5 print("I have a" + animal_type + ".")6 print("My" + animal_type + "'s name is" + pet_name.title() + ".")7

8 describe_pet(animal_type="dog",pet_name="harry")

执行结果：

关键字实参示例：

I have a dog.

My dog's name is Harry.

3.3、默认值参数

在编写函数时，可以给每个形参设定一个固定值，即为默认值。

在调用函数给形参提供实参时，就使用实参值，否则，使用实参的默认值，因此，给形参指定默认值后，在函数调用中省略相应的实参。

1 #默认值参数

2 def describe_pet(pet_name,animal_type = 'dog'):3 """显示宠物信息"""

4 print("\n关键字实参示例：")5 print("I have a" + animal_type + ".")6 print("My" + animal_type + "'s name is" + pet_name.title() + ".")7

8 describe_pet(pet_name="harry")

执行结果：

1 默认值实参示例：2 I have a dog.3 My dog's name is Harry.

注意点：这里把pet_name 放在了前面，原因是在这里还是把它当做是位置参数，如果形参与实参的位置不对应，还是会报错

如果不想使用默认值参数，也可以在调用函数时，将形参定义一个值，这样函数名中的形参默认值就会被忽略。

1 describe_pet(animal_type="cat",pet_name="harry")

3.4、等效的函数调用

什么叫等效的函数调用，即在函数调用时，无论是使用位置参数还是关键字参数、默认值参数、等到的结果都是一样的，这样的方式就是等效调用。

示例：

1 #函数等效调用

2 #一个名为harry 的小狗

3 def describe_pet(pet_name,animal_type = 'dog'):4 describe_pet(pet_name="harry")5 describe_pet("harry")

3.5、避免实参错误

意思就是在进行参数调用时，要给形参传一定的实参。否则会报

最后，欢迎关注我的公众号，这里分享Python/Java技术，自动化、以及认知感悟。

              在函数调用这会涉及到形参与实参个两个概念，于是上网查了一下实参与形参的概念。

              实参是指在函数调用时，必须有确切的值以便赋给形参的一种参数，它可以为常量，变量，表达式，函数等。

              形参是在定义函数名和函数体时使用的一种参数，目的是用于接收调用该函数时传递的参数。它只能是变量。

             1，传值调用，顾名思义，就是对值的传递。但它只是对形参里的值发生了变化，并没有对实参的值有任何变化。接下来我用堆栈法来试试解释， 定义一个函数名为exchange的函数，其作用是实现里面的数交换。代码如下:

#include<stdio.h>

  void  exchange(int one,int another);

  void exchange(int one,int another)   {
      int temp;
      temp=one;
      one=another;
     another=temp;
    }
   void main(void){
    int num1=14,num2=7;
     exchange(num1,num2);
     printf("%d %d\n",num1,num2);
    }

   在主函数定义了两个实参为num1,num2在子函数中定义形参为one,another这种操作等效于one=num1,another=num2。即实参表达式的值在系统堆栈中占用的空间就是与之对应的形参变量的空间。实参先入栈，栈顶指针esp往上飘，即num2先入栈，占据4个字节，接着num1入栈，等效于站在num2上，再占据4个字节，在函数调用时栈底指针ebp移到当前栈顶指针位置，再接着temp入栈，等效于把当前 栈底指针向上的空间分配给了子函数的局部变量即。。。。。。。。。temp，再占据4个字节，函数调用完后恢复到子函数调用之前的栈顶和栈底指针.

  进行temp=one时，等效于把one空间的值赋给temp的空间，即temp为14，
     one=another ,等效于把another空间的值赋给one空间, 即one为7，
     another=temp等效于把temp空间的值赋给another空间,即another为14。
     此刻one和another空间的值分别为7,14但num1和num2空间的值根本就没变。故不能实现交换。

 2，引用调用
    同样的例子用到这个函数中
   void realexchange(int *one,int *another){
         int temp;
         temp=*one;
         *one=*another;
         *another=temp;
      }
     void main(void){
     int num1=14,num2=7;
     realexchange(14,7);

     printf("%d %d\n",num1,num2);

      }
    在主函数定义为这两个实参的取地址即&num1,&num2。这种操作等效于one指向num1,anothor指向num2。如图


    在进行temp=*one时，等效于将one所指空间的值赋给temp的空间，即temp为14;       *one=*another等效于将another所指向的空间的值赋给one所指向的空间，即num1为7;*another=temp等效于把temp空间的值赋给another所指向的空间，即num2为14。这样下来num1与num2的值发生了变化。即转换成功。 
     总而言之，事实上，形参的空间就是实参表达式的值入栈的空间，它并没有额外的申请空间。若在以后形参表达式的值能够影响到实参的结果时，则实参应该传地址给形参，若不需要形参的表达式来改变实参的值时，则只需要传值给形参即可。。。

实参与形参的区别

使用

• 形参出现在函数定义中，在整个函数体内都可以使用，离开该函数则不能使用。

• 实参出现在主调函数中，进入被调函数后，实参变量也不能使用，无法修改。

调用

• 形参变量只有在被调用时才分配内存单元，在调用结束时，即刻释放所分配的内存单元。因此，形参只在函数内部有效。函数调用结束返回主调用函数后则不能再使用该形参变量。

• 实参可以是常量、变量、表达式、函数等，无论实参是何种类型的量，在进行函数调用时，它们都必须有确定的值，以便把这些值传送给形参。因此应预先用赋值，输入等办法使参数获得确定值。

不是指针类型在内存中位置不同：

• 当形参和实参不是指针类型时，在该函数运行时，形参和实参是不同的变量，他们在内存中位于不同的位置，形参将实参的内容复制一份，在该函数运行结束的时候形参被释放，而实参内容不会改变。

• 形参的作用是实现主调函数与被调函数之间的联系，通常将函数所处理的数据，影响函数功能的因素或者函数处理的结果作为形参。

在子函数修改值

无指针通过形参修改实参

#include<stdio.h>
int main()
{
	int a=2,b=3;
	int * af,* bf;
	void exchange(int aa,int bb);//声明函数
	af=&a;
	bf=&b;
	printf("a=%d,b=%d,af=%d,bf=%d\n",a,b,*af,*bf);
	exchange(a,b);
	printf("a=%d,b=%d,af=%d,bf=%d\n",a,b,*af,*bf);

    
}

void exchange(int aa,int bb)
{
	int i;
	i=bb;
	bb=aa;
	aa=i;
}

有指针通过修改地址指向的值来修改实参

#include<stdio.h>
int main()
{
	int a=2,b=3;
	int * af,* bf;
	void exchange(int *aa,int *bb);
	af=&a;
	bf=&b;
	printf("a=%d,b=%d,af=%d,bf=%d\n",a,b,*af,*bf);
	exchange(af,bf);
	printf("a=%d,b=%d,af=%d,bf=%d\n",a,b,*af,*bf);

    
}

void exchange(int *aa,int *bb)
{
	int i;
	i=*bb;
	*bb=*aa;
	*aa=i;
}

有指针通过修改地址来修改实参

通过交换af和bf的地址来改变两者的指向

#include<stdio.h>
int main()
{
	int a=2,b=3;
	int * af,* bf;
	void exchange(int *aa,int *bb);
	af=&a;
	bf=&b;
	printf("a=%d,b=%d,af=%d,bf=%d\n",a,b,*af,*bf);
	exchange(af,bf);
	printf("a=%d,b=%d,af=%d,bf=%d\n",a,b,*af,*bf);
  
    
}

void exchange(int *aa,int *bb)
{
	int* i;
	i=bb;
	bb=aa;
	aa=i;
}

结论

1.无指针通过形参修改实参无法实现：因为实参与形参的值传递是单向传递，实参与形参的地址也不同，两个参数本身是不同的变量。
2.有指针通过修改地址指向的值来修改实参成功：子函数通过指针，即地址找到变量的所在地，直接修改。
3.有指针通过修改地址来修改实参无法实现：同一，在该函数中，指针变量同样是实参与形参的关系，无法双向传导。

附：

定义与声明的区别

1、在一个程序中，变量只能定义一次bai，却可以声明多次；
2、定义分配存储空间，而声明不会。

声明：用于向程序表明变量的类型和名字。

定义也是声明：当定义变量的时候我们声明了它的类型和名字。可以通过使用extern声明变量名而不定义它。不定义变量的声明包括对象名、对象类型和对象类型前的关键字extern。

&、*与地址、变量值的关系

假设

int a=2;
int* aa=&a;

则可得以下结果
a、*aa为变量a的值，为2。
aa、&a为变量a的地址。